@team-agent/installer 0.5.77 → 0.5.80

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

@@ -75,6 +75,12 @@ trait FreshQuickStartLeaderBindingOps {
     fn readback_failure_reason(&self) -> Option<&'static str> {
         None
     }
+    fn frozen_seed_receipt(&self) -> Option<(serde_json::Value, serde_json::Value)> {
+        None
+    }
+    fn this_attempt_extra_state_keys(&self) -> Vec<&'static str> {
+        Vec::new()
+    }
 }
 
 struct RuntimeFreshQuickStartLeaderBindingOps<'a> {
@@ -83,6 +89,8 @@ struct RuntimeFreshQuickStartLeaderBindingOps<'a> {
     cas_conflict: bool,
     applied_grant: Option<(serde_json::Value, serde_json::Value)>,
     registry_receipt: Option<crate::leader::registry::RegistryWriteReceipt>,
+    frozen_owner: Option<serde_json::Value>,
+    frozen_receiver: Option<serde_json::Value>,
     nonce_writer:
         Option<&'a dyn Fn(&str, &PaneId, &str) -> Result<String, crate::leader::LeaderError>>,
 }
@@ -149,17 +157,22 @@ impl FreshQuickStartLeaderBindingOps for RuntimeFreshQuickStartLeaderBindingOps<
             self.last_failure_reason = Some("caller_pane_not_live");
             return false;
         };
-        if !caller_target.active
-            || caller_target
-                .current_path
-                .as_ref()
-                .is_none_or(|path| path.as_os_str().is_empty())
+        if caller_target
+            .current_path
+            .as_ref()
+            .is_none_or(|path| path.as_os_str().is_empty())
         {
             self.last_failure_reason = Some("caller_cwd_unobservable");
             return false;
         }
-        let expected_owner = state.get("team_owner").cloned();
-        let expected_receiver = state.get("leader_receiver").cloned();
+        let expected_owner = self
+            .frozen_owner
+            .clone()
+            .or_else(|| state.get("team_owner").cloned());
+        let expected_receiver = self
+            .frozen_receiver
+            .clone()
+            .or_else(|| state.get("leader_receiver").cloned());
         match crate::leader::attach_leader_to_state_with_target_and_controls(
             workspace,
             state,
@@ -255,8 +268,14 @@ impl FreshQuickStartLeaderBindingOps for RuntimeFreshQuickStartLeaderBindingOps<
     }
 
     fn canonical_readback(&mut self, workspace: &Path, team_key: &str) -> bool {
-        if !launched_team_receiver_is_attached(workspace, team_key) {
-            self.last_failure_reason = Some("registry_readback_unavailable");
+        let class = crate::lifecycle::launch::classify_leader_binding(workspace, team_key);
+        if class != super::LeaderBindingClass::Attached {
+            self.last_failure_reason = Some(match class {
+                super::LeaderBindingClass::IndexMissing => "registry_readback_unavailable",
+                super::LeaderBindingClass::Unknown => "receiver_live_channel_unavailable",
+                super::LeaderBindingClass::Unbound => "receiver_missing",
+                super::LeaderBindingClass::Attached => "registry_identity_mismatch",
+            });
             return false;
         }
         let Ok(resolved) = crate::state::projection::resolve_runtime_team_scope(
@@ -266,7 +285,9 @@ impl FreshQuickStartLeaderBindingOps for RuntimeFreshQuickStartLeaderBindingOps<
             self.last_failure_reason = Some("receiver_scope_unavailable");
             return false;
         };
-        let Some(receiver) = resolved.state.get("leader_receiver") else {
+        let Some(receiver) =
+            super::selected_team_leader_receiver(&resolved.state, team_key)
+        else {
             self.last_failure_reason = Some("receiver_missing");
             return false;
         };
@@ -288,6 +309,12 @@ impl FreshQuickStartLeaderBindingOps for RuntimeFreshQuickStartLeaderBindingOps<
     fn readback_failure_reason(&self) -> Option<&'static str> {
         self.last_failure_reason
     }
+
+    fn frozen_seed_receipt(&self) -> Option<(serde_json::Value, serde_json::Value)> {
+        self.frozen_owner
+            .clone()
+            .zip(self.frozen_receiver.clone())
+    }
 }
 
 const FRESH_BIND_REFUSAL_EVENT: &str = "quick_start.leader_bind_refused";
@@ -300,6 +327,9 @@ fn record_fresh_bind_refusal(
     stage: &'static str,
     reason: &'static str,
 ) {
+    LAST_FRESH_BIND_REFUSAL.with(|cell| {
+        *cell.borrow_mut() = Some((stage, reason));
+    });
     let _ = crate::event_log::EventLog::new(workspace).write(
         FRESH_BIND_REFUSAL_EVENT,
         serde_json::json!({
@@ -311,12 +341,24 @@ fn record_fresh_bind_refusal(
     );
 }
 
+thread_local! {
+    static LAST_FRESH_BIND_REFUSAL: std::cell::RefCell<Option<(&'static str, &'static str)>> =
+        const { std::cell::RefCell::new(None) };
+}
+
+fn take_fresh_bind_refusal() -> Option<(&'static str, &'static str)> {
+    LAST_FRESH_BIND_REFUSAL.with(|cell| cell.borrow_mut().take())
+}
+
 fn refuse_fresh_bind(
     workspace: &Path,
     team_key: &str,
     stage: &'static str,
     reason: &'static str,
 ) -> Result<bool, LifecycleError> {
+    LAST_FRESH_BIND_REFUSAL.with(|cell| {
+        *cell.borrow_mut() = Some((stage, reason));
+    });
     record_fresh_bind_refusal(workspace, team_key, stage, reason);
     Ok(false)
 }
@@ -332,25 +374,6 @@ impl BindingFileSnapshot {
         Self { path, bytes }
     }
 
-    fn restore(&self) {
-        match &self.bytes {
-            Some(bytes) => {
-                let tmp = self.path.with_extension(format!(
-                    "rollback-{}",
-                    std::process::id()
-                ));
-                if std::fs::write(&tmp, bytes).is_ok()
-                    && std::fs::rename(&tmp, &self.path).is_err()
-                {
-                    let _ = std::fs::remove_file(tmp);
-                }
-            }
-            None => {
-                let _ = std::fs::remove_file(&self.path);
-            }
-        }
-    }
-
 }
 
 fn binding_snapshots(workspace: &Path, team_key: &str) -> Vec<BindingFileSnapshot> {
@@ -475,7 +498,7 @@ fn bind_fresh_quick_start_leader_with<O: FreshQuickStartLeaderBindingOps>(
                 workspace,
                 team_key,
                 "strict_provider",
-                "provider_unresolved",
+                "invalid_caller_tuple",
             );
         }
         crate::layout::worker_env::CallerProviderResolution::Absent => {
@@ -503,20 +526,44 @@ fn bind_fresh_quick_start_leader_with<O: FreshQuickStartLeaderBindingOps>(
     // the owner. Cleanup is allowed only when the caller supplies the exact
     // in-memory seed created immediately before this bind attempt and the
     // projected state still contains that seed.
-    let fresh_seeded_binding = seeded_owner.is_some_and(|seed| {
+    let current_receiver = state.get("leader_receiver");
+    let frozen_receipt = ops.frozen_seed_receipt();
+    let fresh_seeded_binding = if let Some((frozen_owner, frozen_receiver)) = frozen_receipt.as_ref()
+    {
         state
             .get("team_owner")
-            .is_some_and(|current| current == seed)
-    });
-    let seeded_receiver = if fresh_seeded_binding {
-        state.get("leader_receiver").cloned()
+            .is_some_and(|current| current == frozen_owner)
+            && current_receiver.is_some_and(|current| current == frozen_receiver)
     } else {
-        None
+        let pending_seed_receiver = current_receiver.is_some_and(|receiver| {
+            receiver.get("status").and_then(serde_json::Value::as_str) == Some("pending")
+                && receiver
+                    .get("discovery")
+                    .and_then(serde_json::Value::as_str)
+                    == Some("quick_start_seed")
+        });
+        seeded_owner.is_some_and(|seed| {
+            state
+                .get("team_owner")
+                .is_some_and(|current| current == seed)
+                && pending_seed_receiver
+        })
     };
+    let seeded_receiver = frozen_receipt
+        .as_ref()
+        .map(|(_, receiver)| receiver.clone())
+        .or_else(|| {
+            if fresh_seeded_binding {
+                current_receiver.cloned()
+            } else {
+                None
+            }
+        });
     // Same-Team owner collision remains fail-closed. Cross-Team registry rows
     // are intentionally irrelevant: pane ids are scoped to their tmux server,
     // and independent endpoints may reuse the same numeric id.
     if has_persisted_binding
+        && !fresh_seeded_binding
         && !persisted_binding_matches_verified_pane(
             &state,
             workspace,
@@ -591,35 +638,53 @@ fn bind_fresh_quick_start_leader_with<O: FreshQuickStartLeaderBindingOps>(
             let registry_rollback_error = ops
                 .registry_receipt()
                 .and_then(|receipt| restore_registry_receipt(&snapshots, &receipt).err());
-            if let Some((expected_owner, expected_receiver)) = cleanup_grant.as_ref() {
+            let state_rollback_error = if let Some((expected_owner, expected_receiver)) =
+                cleanup_grant.as_ref()
+            {
                 clear_fresh_binding_on_refusal(
                     workspace,
                     &mut state,
                     team_key,
                     expected_owner,
                     Some((expected_owner, expected_receiver)),
-                )?;
+                )
+                .err()
             } else if let Some(seed) = seeded_owner.filter(|seed| {
                 state
                     .get("team_owner")
                     .is_some_and(|current| current == *seed)
             }) {
-                clear_fresh_binding_on_refusal(workspace, &mut state, team_key, seed, None)?;
-            }
-            if let Some(error) = registry_rollback_error {
+                clear_fresh_binding_on_refusal(workspace, &mut state, team_key, seed, None).err()
+            } else {
+                restore_this_attempt_state(
+                    workspace,
+                    team_key,
+                    snapshots.first(),
+                    ops.applied_grant().as_ref(),
+                    &ops.this_attempt_extra_state_keys(),
+                )
+                .err()
+            };
+            if let Some(error) =
+                combine_rollback_errors(state_rollback_error, registry_rollback_error)
+            {
                 return Err(error);
             }
         } else {
-            // No caller-seeded owner was ours to clean up. Restore only the
-            // runtime snapshot; a registry write is reverted only with its
-            // exact receipt under the registry owner's lock.
             let registry_rollback_error = ops
                 .registry_receipt()
                 .and_then(|receipt| restore_registry_receipt(&snapshots, &receipt).err());
-            if let Some(snapshot) = snapshots.first() {
-                snapshot.restore();
-            }
-            if let Some(error) = registry_rollback_error {
+            let state_rollback_error = restore_this_attempt_state(
+                workspace,
+                team_key,
+                snapshots.first(),
+                ops.applied_grant().as_ref(),
+                &ops.this_attempt_extra_state_keys(),
+            )
+            .err();
+            if let Some(error) =
+                combine_rollback_errors(state_rollback_error, registry_rollback_error)
+            {
                 return Err(error);
             }
         }
@@ -627,6 +692,112 @@ fn bind_fresh_quick_start_leader_with<O: FreshQuickStartLeaderBindingOps>(
     Ok(committed)
 }
 
+fn combine_rollback_errors(
+    state: Option<LifecycleError>,
+    registry: Option<LifecycleError>,
+) -> Option<LifecycleError> {
+    match (state, registry) {
+        (None, None) => None,
+        (Some(error), None) | (None, Some(error)) => Some(error),
+        (Some(state), Some(registry)) => Some(LifecycleError::StatePersist(format!(
+            "{state}; {registry}"
+        ))),
+    }
+}
+
+fn restore_this_attempt_state(
+    workspace: &Path,
+    team_key: &str,
+    snapshot: Option<&BindingFileSnapshot>,
+    this_grant: Option<&(serde_json::Value, serde_json::Value)>,
+    extra_keys: &[&str],
+) -> Result<(), LifecycleError> {
+    if this_grant.is_none() && extra_keys.is_empty() {
+        return Ok(());
+    }
+    let mut current = match crate::state::persist::load_runtime_state(workspace) {
+        Ok(state) => state,
+        Err(error) => {
+            return Err(LifecycleError::StatePersist(format!(
+                "quick-start binding cleanup failed: {error}"
+            )));
+        }
+    };
+    strip_this_attempt_extra_keys(&mut current, extra_keys);
+    let Some((expected_owner, expected_receiver)) = this_grant else {
+        return crate::state::repository::StateRepository::new(workspace)
+            .save(
+                crate::state::repository::StateWriteIntent::QuickStartBindingCleanup { team_key },
+                &current,
+            )
+            .map_err(|error| {
+                LifecycleError::StatePersist(format!("quick-start binding cleanup failed: {error}"))
+            });
+    };
+    let previous = match snapshot.map(|snapshot| snapshot.bytes.as_deref()) {
+        Some(Some(bytes)) => serde_json::from_slice::<serde_json::Value>(bytes).map_err(|error| {
+            LifecycleError::StatePersist(format!("quick-start binding cleanup failed: {error}"))
+        })?,
+        Some(None) | None => serde_json::Value::Null,
+    };
+    let previous_owner = previous
+        .pointer(&format!("/teams/{team_key}/team_owner"))
+        .cloned()
+        .or_else(|| previous.get("team_owner").cloned())
+        .unwrap_or(serde_json::Value::Null);
+    let previous_receiver = previous
+        .pointer(&format!("/teams/{team_key}/leader_receiver"))
+        .cloned()
+        .or_else(|| previous.get("leader_receiver").cloned())
+        .unwrap_or(serde_json::Value::Null);
+    let no_previous_binding = previous_owner.is_null() && previous_receiver.is_null();
+    if no_previous_binding {
+        if let Some(team) = current
+            .get_mut("teams")
+            .and_then(serde_json::Value::as_object_mut)
+            .and_then(|teams| teams.get_mut(team_key))
+            .and_then(serde_json::Value::as_object_mut)
+        {
+            team.insert("team_owner".to_string(), serde_json::Value::Null);
+            team.insert("leader_receiver".to_string(), serde_json::Value::Null);
+        }
+        return crate::state::repository::StateRepository::new(workspace)
+            .save(
+                crate::state::repository::StateWriteIntent::ClearExactTeamOwnerAndReceiver {
+                    team_key,
+                    seed: expected_owner,
+                    expected_receiver,
+                },
+                &current,
+            )
+            .map_err(|error| {
+                LifecycleError::StatePersist(format!("quick-start binding cleanup failed: {error}"))
+            });
+    }
+    crate::state::repository::StateRepository::new(workspace)
+        .save(
+            crate::state::repository::StateWriteIntent::RestoreExactTeamOwnerAndReceiver {
+                team_key,
+                expected_owner,
+                expected_receiver,
+                previous_owner: &previous_owner,
+                previous_receiver: &previous_receiver,
+            },
+            &current,
+        )
+        .map_err(|error| {
+            LifecycleError::StatePersist(format!("quick-start binding cleanup failed: {error}"))
+        })
+}
+
+fn strip_this_attempt_extra_keys(state: &mut serde_json::Value, extra_keys: &[&str]) {
+    if let Some(root) = state.as_object_mut() {
+        for key in extra_keys {
+            root.remove(*key);
+        }
+    }
+}
+
 fn restore_registry_receipt(
     snapshots: &[BindingFileSnapshot],
     receipt: &crate::leader::registry::RegistryWriteReceipt,
@@ -691,10 +862,91 @@ fn clear_fresh_binding_on_refusal(
         )))
 }
 
+fn existing_runtime_identity_view(
+    state: &serde_json::Value,
+    requested_team: Option<&str>,
+) -> serde_json::Value {
+    let Some(team) = requested_team.filter(|team| !team.is_empty()) else {
+        return state.clone();
+    };
+    let teams = state.get("teams").and_then(serde_json::Value::as_object);
+    if teams.is_some_and(|teams| teams.contains_key(team) || !teams.is_empty()) {
+        return crate::state::projection::project_top_level_view(state, team);
+    }
+    state.clone()
+}
+
+fn preflight_fresh_leader_identity(
+    transport: &dyn Transport,
+) -> Option<(String, Vec<String>, Vec<String>)> {
+    let pane = std::env::var("TMUX_PANE")
+        .ok()
+        .filter(|pane| !pane.is_empty());
+    let current_endpoint = crate::tmux_backend::socket_name_from_tmux_env();
+    match crate::layout::worker_env::caller_provider_resolution(
+        pane.as_deref(),
+        current_endpoint.as_deref(),
+        transport.tmux_endpoint().as_deref(),
+    ) {
+        crate::layout::worker_env::CallerProviderResolution::Invalid => Some((
+            "quick-start refused before spawn: invalid caller tuple".to_string(),
+            vec!["stage=strict_provider reason=invalid_caller_tuple".to_string()],
+            vec![
+                "fix conflicting CALLER_* / TEAM_AGENT_LEADER_* identity; do not run claim-leader"
+                    .to_string(),
+            ],
+        )),
+        crate::layout::worker_env::CallerProviderResolution::Valid(_) => None,
+        crate::layout::worker_env::CallerProviderResolution::Absent => {
+            let Some(pane) = pane else {
+                return None;
+            };
+            let command = transport
+                .query(
+                    &Target::Pane(PaneId::new(pane)),
+                    PaneField::PaneCurrentCommand,
+                )
+                .ok()
+                .flatten()
+                .unwrap_or_default();
+            let explicit = std::env::var("TEAM_AGENT_LEADER_PROVIDER")
+                .ok()
+                .filter(|provider| !provider.is_empty());
+            if command.trim().is_empty() {
+                return Some((
+                    "quick-start refused before spawn: command unobservable".to_string(),
+                    vec!["stage=command_observation reason=command_unobservable".to_string()],
+                    vec![
+                        "run from a live provider pane; do not run claim-leader".to_string(),
+                    ],
+                ));
+            }
+            if crate::leader::owner_bind::strict_owner_bind_provider(
+                explicit.as_deref(),
+                &command,
+            )
+            .is_some()
+            {
+                None
+            } else {
+                Some((
+                    "quick-start refused before spawn: provider unresolved".to_string(),
+                    vec!["stage=strict_provider reason=provider_unresolved".to_string()],
+                    vec![
+                        "set TEAM_AGENT_LEADER_PROVIDER or run from a provider pane; do not run claim-leader"
+                            .to_string(),
+                    ],
+                ))
+            }
+        }
+    }
+}
+
 fn bind_fresh_quick_start_leader(
     workspace: &Path,
     team_key: &str,
     seeded_owner: Option<&serde_json::Value>,
+    seeded_receiver: Option<&serde_json::Value>,
     transport: &dyn Transport,
 ) -> Result<bool, LifecycleError> {
     bind_fresh_quick_start_leader_with(
@@ -707,6 +959,8 @@ fn bind_fresh_quick_start_leader(
             cas_conflict: false,
             applied_grant: None,
             registry_receipt: None,
+            frozen_owner: seeded_owner.cloned(),
+            frozen_receiver: seeded_receiver.cloned(),
             nonce_writer: None,
         },
     )
@@ -982,32 +1236,24 @@ pub(crate) fn quick_start_with_transport_in_workspace_with_display_pi_preflight(
     open_display: bool,
     discover: &mut dyn FnMut(&str) -> Result<Vec<String>, ()>,
 ) -> Result<QuickStartReport, LifecycleError> {
+    // B-7 / 036b N38 三行 fail-fast — TEAM_AGENT_LEADER_PANE_ID 主动路径在 quick-start
+    // 入口验活;死/缺(Dead)的 pane 必须明确报错,不可 silent bind 到 spawner /
+    // owner_bind / lease / display 任一消费点。被动路径(display/seed 等)各自走
+    // 降级+event,不在这里挡。错误三行式:error(含 pane id 字面)/action(unset
+    // 或修 env)/log(env var 名)。
+    let team_workspace = team_workspace(agents_dir);
+    let warning_workspaces = [workspace, team_workspace.as_path()];
+    validate_active_leader_pane_env_with_workspaces(transport, &warning_workspaces)?;
     if !agents_dir.exists() {
         return Err(LifecycleError::Compile(format!(
             "agents dir not found: {}",
             agents_dir.display()
         )));
     }
-    crate::compiler::preflight_pi_models_in_team_with(agents_dir, discover).map_err(|error| {
-        LifecycleError::PiModelPreflight {
-            requested: error.requested,
-            candidates: error.candidates,
-            action: error.action,
-            not_ready: error.not_ready,
-        }
-    })?;
+    crate::lifecycle::launch::run_pi_catalog_preflight(agents_dir, discover)?;
     let workspace = workspace.to_path_buf();
     let mut spec = crate::compiler::compile_team(agents_dir)
         .map_err(|e| LifecycleError::Compile(e.to_string()))?;
-    // B-7 / 036b N38 三行 fail-fast — TEAM_AGENT_LEADER_PANE_ID 主动路径在 quick-start
-    // 入口验活;死/缺(Dead)的 pane 必须明确报错,不可 silent bind 到 spawner /
-    // owner_bind / lease / display 任一消费点。被动路径(display/seed 等)各自走
-    // 降级+event,不在这里挡。错误三行式:error(含 pane id 字面)/action(unset
-    // 或修 env)/log(env var 名)。 Role/schema and Pi model admission above is pure and
-    // must finish before this validation can emit a warning event.
-    let team_workspace = team_workspace(agents_dir);
-    let warning_workspaces = [workspace.as_path(), team_workspace.as_path()];
-    validate_active_leader_pane_env_with_workspaces(transport, &warning_workspaces)?;
     override_spec_workspace(&mut spec, &workspace);
     if !open_display {
         override_spec_display_backend(&mut spec, "none");
@@ -1045,7 +1291,8 @@ pub(crate) fn quick_start_with_transport_in_workspace_with_display_pi_preflight(
             .as_deref()
             .is_none_or(|team| runtime_state_has_quick_start_team(&state, team))
         {
-            let session_name = state
+            let identity = existing_runtime_identity_view(&state, requested_team.as_deref());
+            let session_name = identity
                 .get("session_name")
                 .and_then(serde_json::Value::as_str)
                 .filter(|s| !s.is_empty())
@@ -1053,11 +1300,19 @@ pub(crate) fn quick_start_with_transport_in_workspace_with_display_pi_preflight(
             let attach_commands = session_name
                 .as_ref()
                 .map(|session| {
-                    let windows = quick_start_attach_window_names(&state);
+                    let windows = quick_start_attach_window_names(&identity);
                     attach_commands_for_runtime_windows(
-                        state
+                        identity
                             .get("tmux_endpoint")
                             .and_then(serde_json::Value::as_str)
+                            .or_else(|| {
+                                identity.get("tmux_socket").and_then(serde_json::Value::as_str)
+                            })
+                            .or_else(|| {
+                                state
+                                    .get("tmux_endpoint")
+                                    .and_then(serde_json::Value::as_str)
+                            })
                             .or_else(|| {
                                 state.get("tmux_socket").and_then(serde_json::Value::as_str)
                             }),
@@ -1092,12 +1347,18 @@ pub(crate) fn quick_start_with_transport_in_workspace_with_display_pi_preflight(
                 }
                 next_actions.extend(attach_commands.iter().cloned());
             }
+            let agent_ids = identity
+                .get("agents")
+                .and_then(serde_json::Value::as_object)
+                .map(|agents| agents.keys().cloned().collect::<Vec<_>>())
+                .unwrap_or_default();
             return Ok(QuickStartReport::ExistingRuntime {
                 team: requested_team.clone(),
                 session_name,
                 state_path: Some(state_path),
                 next_actions,
                 attach_commands,
+                agent_ids,
             });
         }
     }
@@ -1113,6 +1374,14 @@ pub(crate) fn quick_start_with_transport_in_workspace_with_display_pi_preflight(
     // team_key 已在入口由显式 id/name 或 compiled spec identity 单次确定。
     let state_team_key = canonical_team_key;
     warn_ignored_owner_team_id(workspace.as_path(), agents_dir, &state_team_key);
+    if let Some((summary, blockers, next_actions)) = preflight_fresh_leader_identity(transport) {
+        return Ok(QuickStartReport::PreflightBlocked {
+            summary,
+            blockers,
+            next_actions,
+            attach_commands: Vec::new(),
+        });
+    }
     // E5 spec 迁移:spec 写到 .team/runtime/<team_key>/(中间产物,绝不落用户目录 agents_dir)。
     // Bug2:原子写(tmp+rename),避免半截 spec。
     let spec_path = crate::model::paths::runtime_spec_path(&workspace, &state_team_key);
@@ -1144,6 +1413,13 @@ pub(crate) fn quick_start_with_transport_in_workspace_with_display_pi_preflight(
                 == Some("quick-start")
         })
         .cloned();
+    let seeded_receiver = state
+        .get("teams")
+        .and_then(serde_json::Value::as_object)
+        .and_then(|teams| teams.get(&state_team_key))
+        .and_then(|team| team.get("leader_receiver"))
+        .cloned()
+        .or_else(|| state.get("leader_receiver").cloned());
     // 0.5.x Phase 1d hot-path 接线(裁决1 msg_76e1d98202b8): use the
     // generic annotator that writes `state.transport = { kind, source }`
     // for every backend AND (for tmux) preserves the existing
@@ -1180,12 +1456,20 @@ pub(crate) fn quick_start_with_transport_in_workspace_with_display_pi_preflight(
     // Fresh initialization owns this one fail-closed bind attempt. It is
     // independent of display layout, so --no-display never suppresses receiver
     // binding. Readiness receives true only after canonical registry readback.
+    let _ = take_fresh_bind_refusal();
     launch.leader_receiver_attached = bind_fresh_quick_start_leader(
         &workspace,
         &state_team_key,
         seeded_owner.as_ref(),
+        seeded_receiver.as_ref(),
         transport,
     )?;
+    if !launch.leader_receiver_attached {
+        if let Some((stage, reason)) = take_fresh_bind_refusal() {
+            launch.leader_bind_stage = Some(stage.to_string());
+            launch.leader_bind_reason = Some(reason.to_string());
+        }
+    }
     launch.session_capture_incomplete_agents =
         quick_start_session_capture_incomplete_agents(&workspace, &state_team_key);
     let coordinator_workspace = crate::coordinator::WorkspacePath::new(workspace.clone());
@@ -1258,6 +1542,7 @@ pub(crate) fn quick_start_with_transport_in_workspace_with_display_pi_preflight(
         attach_commands,
         display_backend,
         worker_readiness,
+        team: state_team_key,
     })
 }
 
@@ -1266,7 +1551,7 @@ mod fresh_quick_start_leader_binding_tests {
     use super::*;
     use crate::layout::worker_env::{CALLER_ENDPOINT_ENV, CALLER_PANE_ENV, CALLER_PROVIDER_ENV};
     use crate::transport::test_support::OfflineTransport;
-    use crate::transport::{PaneInfo, SessionName, WindowName};
+    use crate::transport::{PaneId, PaneInfo, SessionName, WindowName};
     use serde_json::json;
     use std::collections::BTreeMap;
     use std::sync::atomic::{AtomicU64, Ordering};
@@ -1275,7 +1560,7 @@ mod fresh_quick_start_leader_binding_tests {
 
     static SEQUENCE: AtomicU64 = AtomicU64::new(0);
 
-    fn workspace(tag: &str) -> PathBuf {
+    fn workspace_with_provider(tag: &str, provider: &str) -> PathBuf {
         let path = std::env::temp_dir().join(format!(
             "ta-quick-start-bind-{tag}-{}-{}",
             std::process::id(),
@@ -1288,14 +1573,19 @@ mod fresh_quick_start_leader_binding_tests {
                 "active_team_key": "fresh",
                 "team_key": "fresh",
                 "session_name": "team-fresh",
-                "agents": {"sol": {"status": "running", "provider": "pi"}}
+                "agents": {"sol": {"status": "running", "provider": provider}}
             }),
         )
         .unwrap();
         path
     }
 
+    fn workspace(tag: &str) -> PathBuf {
+        workspace_with_provider(tag, "codex")
+    }
+
     struct MockOps {
+        provider: String,
         pane: Option<String>,
         explicit_provider: Option<String>,
         endpoint: Option<String>,
@@ -1308,15 +1598,20 @@ mod fresh_quick_start_leader_binding_tests {
         readback_calls: usize,
         attached_provider: Option<crate::provider::Provider>,
         applied_grant: Option<(serde_json::Value, serde_json::Value)>,
+        frozen_owner: Option<serde_json::Value>,
+        frozen_receiver: Option<serde_json::Value>,
+        last_expected_receiver: Option<serde_json::Value>,
+        extra_state_keys: Vec<&'static str>,
     }
 
     impl Default for MockOps {
         fn default() -> Self {
             Self {
+                provider: "codex".to_string(),
                 pane: Some("%42".to_string()),
-                explicit_provider: Some("pi".to_string()),
+                explicit_provider: Some("codex".to_string()),
                 endpoint: Some("/private/tmp/tmux-test/default".to_string()),
-                command: Some("pi".to_string()),
+                command: Some("codex".to_string()),
                 attach_ok: true,
                 register_ok: true,
                 readback_ok: true,
@@ -1325,55 +1620,22 @@ mod fresh_quick_start_leader_binding_tests {
                 readback_calls: 0,
                 attached_provider: None,
                 applied_grant: None,
+                frozen_owner: None,
+                frozen_receiver: None,
+                last_expected_receiver: None,
+                extra_state_keys: Vec::new(),
             }
         }
     }
 
-    #[test]
-    fn invalid_pi_tool_category_is_rejected_before_runtime_persistence() {
-        let root = std::env::temp_dir().join(format!(
-            "ta-quick-start-pi-tools-{}-{}",
-            std::process::id(),
-            SEQUENCE.fetch_add(1, Ordering::Relaxed)
-        ));
-        let team = root.join(".team/current");
-        std::fs::create_dir_all(team.join("agents")).unwrap();
-        std::fs::write(
-            team.join("TEAM.md"),
-            "---\nname: pi-tools\nprovider: pi\n---\n\nPi team.\n",
-        )
-        .unwrap();
-        std::fs::write(
-            team.join("agents/worker.md"),
-            "---\nname: worker\nrole: Worker\nprovider: pi\nauth_mode: subscription\ndangerously_skip_permissions: false\ntools:\n  - mcp_team\n  - fs_read\n  - provider_builtin\n---\n\nWorker.\n",
-        )
-        .unwrap();
-
-        let transport = crate::transport::test_support::OfflineTransport::new();
-        let mut discover = |_requested: &str| -> Result<Vec<String>, ()> { Err(()) };
-        let error = quick_start_with_transport_in_workspace_with_display_pi_preflight(
-            &root,
-            &team,
-            None,
-            true,
-            None,
-            &transport,
-            false,
-            &mut discover,
-        )
-        .expect_err("invalid Pi category must fail before quick-start persistence");
-        let error = error.to_string();
-        assert!(error.contains("Pi does not support Team Agent tool category \"provider_builtin\""));
-        assert!(error.contains("remove it from the role's tools"));
-        assert!(
-            !crate::state::persist::runtime_state_path(&root).exists(),
-            "quick-start validation failure must not persist runtime state"
-        );
-        assert!(
-            !root.join(".team/runtime").exists(),
-            "quick-start validation failure must not create runtime artifacts"
-        );
-        let _ = std::fs::remove_dir_all(root);
+    impl MockOps {
+        fn with_provider(provider: &str) -> Self {
+            let mut ops = Self::default();
+            ops.provider = provider.to_string();
+            ops.explicit_provider = Some(provider.to_string());
+            ops.command = Some(provider.to_string());
+            ops
+        }
     }
 
     impl FreshQuickStartLeaderBindingOps for MockOps {
@@ -1406,6 +1668,7 @@ mod fresh_quick_start_leader_binding_tests {
             if !self.attach_ok {
                 state["failed_attach_mutation"] = json!(true);
                 let _ = crate::state::persist::save_runtime_state(workspace, state);
+                self.extra_state_keys.push("failed_attach_mutation");
                 return false;
             }
             let team_key = state
@@ -1413,12 +1676,19 @@ mod fresh_quick_start_leader_binding_tests {
                 .and_then(serde_json::Value::as_str)
                 .unwrap_or("fresh")
                 .to_string();
-            let expected_owner = state.get("team_owner").cloned();
-            let expected_receiver = state.get("leader_receiver").cloned();
+            let expected_owner = self
+                .frozen_owner
+                .clone()
+                .or_else(|| state.get("team_owner").cloned());
+            let expected_receiver = self
+                .frozen_receiver
+                .clone()
+                .or_else(|| state.get("leader_receiver").cloned());
+            self.last_expected_receiver = expected_receiver.clone();
             let owner = expected_owner.clone().unwrap_or_else(|| {
                 json!({
                     "pane_id": pane.as_str(),
-                    "provider": "pi",
+                    "provider": self.provider.as_str(),
                     "leader_session_uuid": "uuid-fresh",
                     "owner_epoch": 1
                 })
@@ -1431,7 +1701,7 @@ mod fresh_quick_start_leader_binding_tests {
                 "mode": "direct_tmux",
                 "pane_id": pane.as_str(),
                 "status": "attached",
-                "provider": "pi",
+                "provider": self.provider.as_str(),
                 "leader_session_uuid": "uuid-fresh",
                 "owner_epoch": owner_epoch,
                 "tmux_socket": self.endpoint
@@ -1471,6 +1741,16 @@ mod fresh_quick_start_leader_binding_tests {
             self.applied_grant.clone()
         }
 
+        fn frozen_seed_receipt(&self) -> Option<(serde_json::Value, serde_json::Value)> {
+            self.frozen_owner
+                .clone()
+                .zip(self.frozen_receiver.clone())
+        }
+
+        fn this_attempt_extra_state_keys(&self) -> Vec<&'static str> {
+            self.extra_state_keys.clone()
+        }
+
         fn register(&mut self, workspace: &Path, team_key: &str) -> bool {
             self.register_calls += 1;
             let mut persisted = crate::state::persist::load_runtime_state(workspace).unwrap();
@@ -1487,6 +1767,7 @@ mod fresh_quick_start_leader_binding_tests {
             if !self.register_ok {
                 persisted["failed_registry_mutation"] = json!(true);
                 crate::state::persist::save_runtime_state(workspace, &persisted).unwrap();
+                self.extra_state_keys.push("failed_registry_mutation");
             }
             self.register_ok
         }
@@ -1497,6 +1778,7 @@ mod fresh_quick_start_leader_binding_tests {
             if !self.readback_ok {
                 persisted["failed_readback_mutation"] = json!(true);
                 crate::state::persist::save_runtime_state(workspace, &persisted).unwrap();
+                self.extra_state_keys.push("failed_readback_mutation");
             }
             self.readback_ok
                 && persisted
@@ -1509,12 +1791,12 @@ mod fresh_quick_start_leader_binding_tests {
     }
 
     #[test]
-    fn fresh_binding_persists_then_registers_then_requires_canonical_readback() {
+    fn fresh_binding_persists_then_registers_then_requires_canonical_readback_provider_independent() {
         let workspace = workspace("positive");
         let mut ops = MockOps::default();
         assert!(bind_fresh_quick_start_leader_with(&workspace, "fresh", None, &mut ops)
             .unwrap());
-        assert_eq!(ops.attached_provider, Some(crate::provider::Provider::Pi));
+        assert_eq!(ops.attached_provider, Some(crate::provider::Provider::Codex));
         assert_eq!(ops.attach_calls, 1);
         assert_eq!(ops.register_calls, 1);
         assert_eq!(ops.readback_calls, 1);
@@ -1538,6 +1820,146 @@ mod fresh_quick_start_leader_binding_tests {
         );
     }
 
+    fn seed_fresh_receipts(
+        workspace: &std::path::Path,
+    ) -> (serde_json::Value, serde_json::Value, serde_json::Value) {
+        let mut state = crate::state::persist::load_runtime_state(workspace).unwrap();
+        let caller = crate::state::owner_gate::CallerIdentity {
+            pane_id: "%42".to_string(),
+            provider: "codex".to_string(),
+            machine_fingerprint: "fp".to_string(),
+            leader_session_uuid: "uuid-fresh".to_string(),
+            leader_session_uuid_source: "env".to_string(),
+        };
+        assert!(super::spec_state::seed_launched_owner_from_caller_with_provider_lookup(
+            &mut state,
+            caller,
+            |_| None
+        ));
+        let owner = state
+            .pointer("/teams/fresh/team_owner")
+            .cloned()
+            .expect("seed owner");
+        let receiver = state
+            .pointer("/teams/fresh/leader_receiver")
+            .cloned()
+            .expect("seed receiver");
+        assert_eq!(
+            receiver.get("status").and_then(serde_json::Value::as_str),
+            Some("pending")
+        );
+        crate::state::persist::save_runtime_state(workspace, &state).unwrap();
+        (state, owner, receiver)
+    }
+
+    #[test]
+    #[serial_test::serial(env)]
+    fn fresh_seed_exemption_requires_frozen_receiver_receipt() {
+        let workspace = workspace("frozen-seed");
+        let (_state, owner, frozen_receiver) = seed_fresh_receipts(&workspace);
+        let mut ops = MockOps {
+            frozen_owner: Some(owner.clone()),
+            frozen_receiver: Some(frozen_receiver.clone()),
+            ..MockOps::default()
+        };
+        assert!(bind_fresh_quick_start_leader_with(
+            &workspace,
+            "fresh",
+            Some(&owner),
+            &mut ops
+        )
+        .unwrap());
+        assert_eq!(ops.attach_calls, 1);
+        assert_eq!(ops.last_expected_receiver, Some(frozen_receiver));
+        let _ = std::fs::remove_dir_all(&workspace);
+    }
+
+    #[test]
+    #[serial_test::serial(env)]
+    fn newer_pending_receiver_is_not_cas_expected() {
+        let workspace = workspace("newer-pending");
+        let (mut state, owner, frozen_receiver) = seed_fresh_receipts(&workspace);
+        let mut newer = frozen_receiver.clone();
+        newer["pane_id"] = json!("%99");
+        newer["nonce"] = json!("winner");
+        state["leader_receiver"] = newer.clone();
+        state["teams"]["fresh"]["leader_receiver"] = newer.clone();
+        crate::state::persist::save_runtime_state_with_receiver_authority(
+            &workspace,
+            &state,
+            "fresh",
+            None,
+        )
+        .unwrap();
+        let on_disk = crate::state::persist::load_runtime_state(&workspace).unwrap();
+        assert_eq!(
+            on_disk
+                .pointer("/teams/fresh/leader_receiver")
+                .cloned()
+                .as_ref(),
+            Some(&newer),
+            "pending winner must be on disk before bind"
+        );
+        let mut ops = MockOps {
+            frozen_owner: Some(owner.clone()),
+            frozen_receiver: Some(frozen_receiver),
+            ..MockOps::default()
+        };
+        assert!(!bind_fresh_quick_start_leader_with(
+            &workspace,
+            "fresh",
+            Some(&owner),
+            &mut ops
+        )
+        .unwrap());
+        assert_eq!(ops.attach_calls, 0);
+        assert_eq!(ops.last_expected_receiver, None);
+        let _ = std::fs::remove_dir_all(&workspace);
+    }
+
+    #[test]
+    #[serial_test::serial(env)]
+    fn newer_attached_receiver_is_kept() {
+        let workspace = workspace("newer-attached");
+        let (mut state, owner, frozen_receiver) = seed_fresh_receipts(&workspace);
+        let mut winner = frozen_receiver.clone();
+        winner["status"] = json!("attached");
+        winner["pane_id"] = json!("%99");
+        state["leader_receiver"] = winner.clone();
+        state["teams"]["fresh"]["leader_receiver"] = winner.clone();
+        crate::state::persist::save_runtime_state_with_receiver_authority(
+            &workspace,
+            &state,
+            "fresh",
+            None,
+        )
+        .unwrap();
+        let on_disk = crate::state::persist::load_runtime_state(&workspace).unwrap();
+        assert_eq!(
+            on_disk
+                .pointer("/teams/fresh/leader_receiver")
+                .cloned()
+                .as_ref(),
+            Some(&winner),
+            "attached winner must be on disk before bind"
+        );
+        let mut ops = MockOps {
+            frozen_owner: Some(owner.clone()),
+            frozen_receiver: Some(frozen_receiver),
+            ..MockOps::default()
+        };
+        assert!(!bind_fresh_quick_start_leader_with(
+            &workspace,
+            "fresh",
+            Some(&owner),
+            &mut ops
+        )
+        .unwrap());
+        assert_eq!(ops.attach_calls, 0);
+        assert_eq!(ops.last_expected_receiver, None);
+        let _ = std::fs::remove_dir_all(&workspace);
+    }
+
     #[test]
     fn fresh_bind_refusal_event_keeps_first_safe_stage_and_reason() {
         for (case, expected_stage, expected_reason) in [
@@ -1671,16 +2093,18 @@ mod fresh_quick_start_leader_binding_tests {
                 | "dual_state_mismatch" => {
                     state["workspace"] = json!(workspace);
                     state["team_owner"] = json!({
-                        "pane_id": "%42", "provider": "pi",
+                        "pane_id": "%42", "provider": "codex",
                         "leader_session_uuid": "uuid-fresh", "owner_epoch": 1
                     });
                     state["leader_receiver"] = json!({
                         "mode": "direct_tmux", "status": "attached", "pane_id": "%42",
-                        "provider": "pi", "leader_session_uuid": "uuid-fresh", "owner_epoch": 1,
+                        "provider": "codex", "leader_session_uuid": "uuid-fresh", "owner_epoch": 1,
                         "tmux_socket": "/private/tmp/tmux-test/default"
                     });
                     match case {
-                        "provider_mismatch" => state["leader_receiver"]["provider"] = json!("codex"),
+                        "provider_mismatch" => {
+                            state["leader_receiver"]["provider"] = json!("claude")
+                        },
                         "socket_mismatch" => state["leader_receiver"]["tmux_socket"] = json!("/tmp/other"),
                         "workspace_mismatch" => state["workspace"] = json!(workspace.join("other")),
                         "dual_state_mismatch" => state["team_owner"]["owner_epoch"] = json!(2),
@@ -1739,7 +2163,7 @@ mod fresh_quick_start_leader_binding_tests {
                 "active_team_key": "fresh",
                 "team_key": "fresh",
                 "session_name": "team-fresh",
-                "agents": {"sol": {"status": "running", "provider": "pi"}},
+                "agents": {"sol": {"status": "running", "provider": "codex"}},
                 "teams": {
                     "current": {
                         "team_key": "current",
@@ -1750,10 +2174,10 @@ mod fresh_quick_start_leader_binding_tests {
                         "workspace": workspace,
                         "team_key": "fresh",
                         "session_name": "team-fresh",
-                        "agents": {"sol": {"status": "running", "provider": "pi"}},
+                        "agents": {"sol": {"status": "running", "provider": "codex"}},
                         "team_owner": {
                             "pane_id": "%42",
-                            "provider": "pi",
+                            "provider": "codex",
                             "leader_session_uuid": "uuid-fresh",
                             "owner_epoch": 1
                         },
@@ -1761,7 +2185,7 @@ mod fresh_quick_start_leader_binding_tests {
                             "mode": "direct_tmux",
                             "status": "attached",
                             "pane_id": "%42",
-                            "provider": "pi",
+                            "provider": "codex",
                             "leader_session_uuid": "uuid-fresh",
                             "owner_epoch": 1,
                             "tmux_socket": ambient
@@ -1787,7 +2211,7 @@ mod fresh_quick_start_leader_binding_tests {
         }
 
         fn explicit_provider(&mut self) -> Option<String> {
-            Some("pi".to_string())
+            Some("codex".to_string())
         }
 
         fn tmux_endpoint(&mut self) -> Option<String> {
@@ -1795,7 +2219,7 @@ mod fresh_quick_start_leader_binding_tests {
         }
 
         fn observe_command(&mut self, _pane: &PaneId) -> Option<String> {
-            Some("pi".to_string())
+            Some("codex".to_string())
         }
 
         fn attach(
@@ -1845,8 +2269,28 @@ mod fresh_quick_start_leader_binding_tests {
             attach_calls: 0,
             registry_receipt: None,
         };
-        assert!(bind_fresh_quick_start_leader_with(&workspace, "fresh", None, &mut ops)
-            .unwrap());
+        let endpoint = "/private/tmp/tmux-test/default";
+        let transport = OfflineTransport::default()
+            .with_tmux_endpoint(endpoint)
+            .with_targets(vec![PaneInfo {
+                pane_id: PaneId::new("%42"),
+                session: SessionName::new("s"),
+                window_index: None,
+                window_name: None,
+                pane_index: None,
+                tty: None,
+                current_command: Some("codex".to_string()),
+                current_path: Some(workspace.clone()),
+                active: true,
+                pane_pid: None,
+                leader_env: Default::default(),
+            }]);
+        assert!(crate::transport_factory::with_leader_endpoint_transport(
+            endpoint,
+            transport,
+            || bind_fresh_quick_start_leader_with(&workspace, "fresh", None, &mut ops)
+        )
+        .unwrap());
         assert_eq!(ops.attach_calls, 0, "preseeded dual state must not reattach");
         let path = crate::leader::registry::registry_dir().unwrap().join(format!(
             "{}__fresh.json",
@@ -1867,7 +2311,7 @@ mod fresh_quick_start_leader_binding_tests {
         state["workspace"] = json!(workspace);
         state["team_owner"] = json!({
             "pane_id": "%old",
-            "provider": "pi",
+            "provider": "codex",
             "leader_session_uuid": "uuid-old",
             "owner_epoch": 4,
             "claimed_via": "quick-start"
@@ -1876,7 +2320,7 @@ mod fresh_quick_start_leader_binding_tests {
             "mode": "direct_tmux",
             "status": "attached",
             "pane_id": "%old",
-            "provider": "pi",
+            "provider": "codex",
             "leader_session_uuid": "uuid-old",
             "owner_epoch": 4,
             "tmux_socket": "/private/tmp/tmux-test/old"
@@ -1897,7 +2341,7 @@ mod fresh_quick_start_leader_binding_tests {
     fn matching_seed() -> serde_json::Value {
         json!({
             "pane_id": "%42",
-            "provider": "pi",
+            "provider": "codex",
             "leader_session_uuid": "uuid-fresh",
             "owner_epoch": 1,
             "claimed_via": "quick-start"
@@ -1909,16 +2353,29 @@ mod fresh_quick_start_leader_binding_tests {
             "mode": "direct_tmux",
             "status": "attached",
             "pane_id": "%42",
-            "provider": "pi",
+            "provider": "codex",
             "leader_session_uuid": "uuid-fresh",
             "owner_epoch": 1,
             "tmux_socket": "/private/tmp/tmux-test/default"
         })
     }
 
-    fn workspace_with_matching_seed(tag: &str) -> (PathBuf, serde_json::Value) {
-        let workspace = workspace(tag);
-        let seed = matching_seed();
+    fn matching_pending_receiver() -> serde_json::Value {
+        json!({
+            "mode": "direct_tmux",
+            "status": "pending",
+            "discovery": "quick_start_seed",
+            "pane_id": "%42",
+            "provider": "codex",
+            "leader_session_uuid": "uuid-fresh",
+            "owner_epoch": 1,
+            "tmux_socket": "/private/tmp/tmux-test/default"
+        })
+    }
+
+    fn workspace_with_fresh_seed(tag: &str) -> (PathBuf, serde_json::Value) {
+        let workspace = workspace(tag);
+        let seed = matching_seed();
         crate::state::persist::save_runtime_state(
             &workspace,
             &json!({
@@ -1926,13 +2383,46 @@ mod fresh_quick_start_leader_binding_tests {
                 "active_team_key": "fresh",
                 "team_key": "fresh",
                 "session_name": "team-fresh",
-                "agents": {"sol": {"status": "running", "provider": "pi"}},
+                "agents": {"sol": {"status": "running", "provider": "codex"}},
+                "team_owner": seed,
+                "leader_receiver": matching_pending_receiver(),
                 "teams": {
                     "fresh": {
                         "workspace": workspace,
                         "team_key": "fresh",
                         "session_name": "team-fresh",
-                        "agents": {"sol": {"status": "running", "provider": "pi"}},
+                        "agents": {"sol": {"status": "running", "provider": "codex"}},
+                        "team_owner": seed,
+                        "leader_receiver": matching_pending_receiver(),
+                        "owner_epoch": 1
+                    }
+                }
+            }),
+        )
+        .unwrap();
+        let seed = crate::state::persist::load_runtime_state(&workspace).unwrap()["teams"]["fresh"]
+            ["team_owner"]
+            .clone();
+        (workspace, seed)
+    }
+
+    fn workspace_with_matching_seed(tag: &str) -> (PathBuf, serde_json::Value) {
+        let workspace = workspace(tag);
+        let seed = matching_seed();
+        crate::state::persist::save_runtime_state(
+            &workspace,
+            &json!({
+                "workspace": workspace,
+                "active_team_key": "fresh",
+                "team_key": "fresh",
+                "session_name": "team-fresh",
+                "agents": {"sol": {"status": "running", "provider": "codex"}},
+                "teams": {
+                    "fresh": {
+                        "workspace": workspace,
+                        "team_key": "fresh",
+                        "session_name": "team-fresh",
+                        "agents": {"sol": {"status": "running", "provider": "codex"}},
                         "team_owner": seed,
                         "leader_receiver": matching_receiver(),
                         "owner_epoch": 1
@@ -2078,7 +2568,7 @@ mod fresh_quick_start_leader_binding_tests {
 
     #[test]
     fn seeded_cleanup_clears_exact_seed_through_bind_repository_entry() {
-        let (workspace, seed) = workspace_with_matching_seed("seed-cleanup-success");
+        let (workspace, seed) = workspace_with_fresh_seed("seed-cleanup-success");
         let mut ops = failed_register_ops(None, false);
         assert!(!bind_fresh_quick_start_leader_with(
             &workspace,
@@ -2094,7 +2584,8 @@ mod fresh_quick_start_leader_binding_tests {
             .applied_grant
             .as_ref()
             .is_some_and(|(owner, receiver)| {
-                owner == &seed && receiver == &matching_receiver()
+                owner == &seed
+                    && receiver.get("pane_id").and_then(serde_json::Value::as_str) == Some("%42")
             }));
         let persisted = crate::state::persist::load_runtime_state(&workspace).unwrap();
         assert!(
@@ -2154,7 +2645,7 @@ mod fresh_quick_start_leader_binding_tests {
 
     #[test]
     fn seeded_cleanup_propagates_persist_error() {
-        let (workspace, seed) = workspace_with_matching_seed("seed-cleanup-persist-err");
+        let (workspace, seed) = workspace_with_fresh_seed("seed-cleanup-persist-err");
         let mut ops = failed_register_ops(None, true);
         let error = bind_fresh_quick_start_leader_with(
             &workspace,
@@ -2170,7 +2661,8 @@ mod fresh_quick_start_leader_binding_tests {
             .applied_grant
             .as_ref()
             .is_some_and(|(owner, receiver)| {
-                owner == &seed && receiver == &matching_receiver()
+                owner == &seed
+                    && receiver.get("pane_id").and_then(serde_json::Value::as_str) == Some("%42")
             }));
         match error {
             LifecycleError::StatePersist(text) => {
@@ -2184,60 +2676,375 @@ mod fresh_quick_start_leader_binding_tests {
         let _ = std::fs::remove_dir_all(crate::state::persist::runtime_state_path(&workspace));
     }
 
-    #[test]
-    fn attach_registry_or_readback_failure_rolls_back_exact_state_bytes() {
-        for (case, mut ops) in [
-            (
-                "attach-failure",
-                MockOps {
-                    attach_ok: false,
-                    ..MockOps::default()
-                },
-            ),
-            (
-                "registry-failure",
-                MockOps {
-                    register_ok: false,
-                    ..MockOps::default()
-                },
-            ),
-            (
-                "readback-failure",
-                MockOps {
-                    readback_ok: false,
-                    ..MockOps::default()
-                },
-            ),
+    fn complete_normalized_state() -> serde_json::Value {
+        json!({
+            "active_team_key": "fresh",
+            "team_key": "fresh",
+            "session_name": "team-fresh",
+            "agents": {
+                "sol": {
+                    "status": "running",
+                    "provider": "codex",
+                    "session_id": null,
+                    "rollout_path": null,
+                    "captured_at": null,
+                    "captured_via": null,
+                    "attribution_confidence": null,
+                    "spawn_cwd": null
+                }
+            }
+        })
+    }
+
+    fn persist_complete_normalized_baseline(workspace: &Path) -> (Vec<u8>, serde_json::Value) {
+        let state = complete_normalized_state();
+        let path = crate::state::persist::runtime_state_path(workspace);
+        if let Some(parent) = path.parent() {
+            std::fs::create_dir_all(parent).unwrap();
+        }
+        std::fs::write(&path, serde_json::to_string_pretty(&state).unwrap()).unwrap();
+        let _ = crate::state::persist::load_runtime_state(workspace).unwrap();
+        let raw = std::fs::read(&path).unwrap();
+        let on_disk: serde_json::Value = serde_json::from_slice(&raw).unwrap();
+        for field in [
+            "session_id",
+            "rollout_path",
+            "captured_at",
+            "captured_via",
+            "attribution_confidence",
+            "spawn_cwd",
         ] {
-            let workspace = workspace(case);
-            let state_path = crate::state::persist::runtime_state_path(&workspace);
-            let before = std::fs::read(&state_path).unwrap();
-            assert!(!bind_fresh_quick_start_leader_with(&workspace, "fresh", None, &mut ops)
-                .unwrap());
             assert_eq!(
-                std::fs::read(&state_path).unwrap(),
-                before,
-                "{case} left partial state bytes"
+                on_disk.pointer(&format!("/agents/sol/{field}")),
+                Some(&json!(null)),
+                "normalized baseline missing {field}"
             );
-            match case {
-                "attach-failure" => {
-                    assert_eq!(ops.attach_calls, 1);
-                    assert_eq!(ops.register_calls, 0);
-                    assert_eq!(ops.readback_calls, 0);
-                }
-                "registry-failure" => {
-                    assert_eq!(ops.attach_calls, 1);
-                    assert_eq!(ops.register_calls, 1);
-                    assert_eq!(ops.readback_calls, 0);
-                }
-                "readback-failure" => {
-                    assert_eq!(ops.attach_calls, 1);
-                    assert_eq!(ops.register_calls, 1);
-                    assert_eq!(ops.readback_calls, 1);
-                }
-                _ => unreachable!(),
-            }
         }
+        assert_eq!(on_disk.get("team_key"), Some(&json!("fresh")));
+        (raw, on_disk)
+    }
+
+    fn clear_exact_expected_bytes(baseline: &serde_json::Value) -> Vec<u8> {
+        let mut expected = baseline.clone();
+        expected["teams"] = json!({
+            "fresh": {
+                "leader_receiver": null,
+                "team_owner": null,
+                "owner_epoch": 1
+            }
+        });
+        serde_json::to_string_pretty(&expected).unwrap().into_bytes()
+    }
+
+    fn assert_failure_rolls_back_this_attempt(
+        case: &str,
+        mut ops: MockOps,
+        attach_calls: usize,
+        register_calls: usize,
+        readback_calls: usize,
+        clear_exact: bool,
+    ) {
+        let workspace = workspace(case);
+        let state_path = crate::state::persist::runtime_state_path(&workspace);
+        let (before, baseline) = persist_complete_normalized_baseline(&workspace);
+        let expected = if clear_exact {
+            clear_exact_expected_bytes(&baseline)
+        } else {
+            before
+        };
+        assert!(
+            !bind_fresh_quick_start_leader_with(&workspace, "fresh", None, &mut ops).unwrap(),
+            "{case} must refuse"
+        );
+        assert_eq!(ops.attach_calls, attach_calls, "{case} attach_calls");
+        assert_eq!(ops.register_calls, register_calls, "{case} register_calls");
+        assert_eq!(ops.readback_calls, readback_calls, "{case} readback_calls");
+        let after = crate::state::persist::load_runtime_state(&workspace).unwrap();
+        assert!(
+            after.get("failed_attach_mutation").is_none(),
+            "{case} left failed_attach_mutation"
+        );
+        assert!(
+            after.get("failed_registry_mutation").is_none(),
+            "{case} left failed_registry_mutation"
+        );
+        assert!(
+            after.get("failed_readback_mutation").is_none(),
+            "{case} left failed_readback_mutation"
+        );
+        assert!(
+            after
+                .pointer("/teams/fresh/leader_receiver")
+                .is_none_or(serde_json::Value::is_null),
+            "{case} left a live leader_receiver"
+        );
+        assert!(
+            after
+                .pointer("/teams/fresh/team_owner")
+                .is_none_or(serde_json::Value::is_null),
+            "{case} left a live team_owner"
+        );
+        assert_eq!(
+            std::fs::read(&state_path).unwrap(),
+            expected,
+            "{case} left partial state bytes"
+        );
+        let _ = std::fs::remove_dir_all(&workspace);
+    }
+
+    #[test]
+    fn attach_registry_or_readback_failure_rolls_back_exact_state_bytes() {
+        assert_failure_rolls_back_this_attempt(
+            "attach-failure",
+            MockOps {
+                attach_ok: false,
+                ..MockOps::default()
+            },
+            1,
+            0,
+            0,
+            false,
+        );
+        assert_failure_rolls_back_this_attempt(
+            "registry-failure",
+            MockOps {
+                register_ok: false,
+                ..MockOps::default()
+            },
+            1,
+            1,
+            0,
+            true,
+        );
+        assert_failure_rolls_back_this_attempt(
+            "readback-failure",
+            MockOps {
+                readback_ok: false,
+                ..MockOps::default()
+            },
+            1,
+            1,
+            1,
+            true,
+        );
+    }
+
+    #[test]
+    fn attach_failure_rolls_back_exact_state_bytes() {
+        assert_failure_rolls_back_this_attempt(
+            "attach-failure-only",
+            MockOps {
+                attach_ok: false,
+                ..MockOps::default()
+            },
+            1,
+            0,
+            0,
+            false,
+        );
+    }
+
+    #[test]
+    fn registry_failure_rolls_back_exact_state_bytes() {
+        assert_failure_rolls_back_this_attempt(
+            "registry-failure-only",
+            MockOps {
+                register_ok: false,
+                ..MockOps::default()
+            },
+            1,
+            1,
+            0,
+            true,
+        );
+    }
+
+    #[test]
+    fn attach_failure_keeps_unrelated_fields() {
+        let workspace = workspace("unrelated-fields");
+        let mut state = crate::state::persist::load_runtime_state(&workspace).unwrap();
+        state["tasks"] = json!({"keep": true});
+        crate::state::persist::save_runtime_state(&workspace, &state).unwrap();
+        let mut ops = MockOps {
+            attach_ok: false,
+            ..MockOps::default()
+        };
+        assert!(!bind_fresh_quick_start_leader_with(&workspace, "fresh", None, &mut ops)
+            .unwrap());
+        let after = crate::state::persist::load_runtime_state(&workspace).unwrap();
+        assert_eq!(after.get("tasks"), Some(&json!({"keep": true})));
+        assert!(after.get("failed_attach_mutation").is_none());
+        let _ = std::fs::remove_dir_all(&workspace);
+    }
+
+    fn complete_owner(pane: &str, provider: &str, uuid: &str, epoch: u64) -> serde_json::Value {
+        json!({
+            "pane_id": pane,
+            "provider": provider,
+            "leader_session_uuid": uuid,
+            "owner_epoch": epoch
+        })
+    }
+
+    fn complete_receiver(
+        pane: &str,
+        provider: &str,
+        uuid: &str,
+        epoch: u64,
+        socket: &str,
+    ) -> serde_json::Value {
+        json!({
+            "mode": "direct_tmux",
+            "status": "attached",
+            "pane_id": pane,
+            "provider": provider,
+            "leader_session_uuid": uuid,
+            "owner_epoch": epoch,
+            "tmux_socket": socket
+        })
+    }
+
+    fn commit_fresh_binding(
+        workspace: &Path,
+        owner: &serde_json::Value,
+        receiver: &serde_json::Value,
+        epoch: u64,
+    ) {
+        let mut state = crate::state::persist::load_runtime_state(workspace).unwrap();
+        state["teams"]["fresh"]["team_owner"] = owner.clone();
+        state["teams"]["fresh"]["leader_receiver"] = receiver.clone();
+        state["teams"]["fresh"]["owner_epoch"] = json!(epoch);
+        crate::state::persist::save_runtime_state_with_receiver_authority(
+            workspace,
+            &state,
+            "fresh",
+            None,
+        )
+        .unwrap();
+        let raw = std::fs::read(crate::state::persist::runtime_state_path(workspace)).unwrap();
+        let on_disk: serde_json::Value = serde_json::from_slice(&raw).unwrap();
+        assert_eq!(
+            on_disk.pointer("/teams/fresh/team_owner"),
+            Some(owner),
+            "committed owner must equal predetermined pair"
+        );
+        assert_eq!(
+            on_disk.pointer("/teams/fresh/leader_receiver"),
+            Some(receiver),
+            "committed receiver must equal predetermined pair"
+        );
+        assert_eq!(
+            on_disk.pointer("/teams/fresh/owner_epoch"),
+            Some(&json!(epoch)),
+            "canonical epoch must match the pair"
+        );
+    }
+
+    #[test]
+    fn restore_exact_restores_previous_owner_receiver() {
+        let workspace = workspace("restore-exact-prev");
+        let _ = persist_complete_normalized_baseline(&workspace);
+        let mut state = crate::state::persist::load_runtime_state(&workspace).unwrap();
+        state["tasks"] = json!({"keep": true});
+        crate::state::persist::save_runtime_state(&workspace, &state).unwrap();
+        let previous_uuid = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+        let previous_owner = complete_owner("%99", "codex", previous_uuid, 1);
+        let previous_receiver =
+            complete_receiver("%99", "codex", previous_uuid, 1, "/tmp/prev.sock");
+        commit_fresh_binding(&workspace, &previous_owner, &previous_receiver, 1);
+        let snapshot = super::BindingFileSnapshot::capture(
+            crate::state::persist::runtime_state_path(&workspace),
+        );
+        let this_uuid = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
+        let this_owner = complete_owner("%42", "codex", this_uuid, 1);
+        let this_receiver = complete_receiver(
+            "%42",
+            "codex",
+            this_uuid,
+            1,
+            "/private/tmp/tmux-test/default",
+        );
+        commit_fresh_binding(&workspace, &this_owner, &this_receiver, 1);
+        let this_receipt = (this_owner.clone(), this_receiver.clone());
+        assert_ne!(this_owner, previous_owner);
+        assert_ne!(this_receiver, previous_receiver);
+        super::restore_this_attempt_state(
+            &workspace,
+            "fresh",
+            Some(&snapshot),
+            Some(&this_receipt),
+            &[],
+        )
+        .unwrap();
+        let after = crate::state::persist::load_runtime_state(&workspace).unwrap();
+        assert_eq!(after["teams"]["fresh"]["team_owner"], previous_owner);
+        assert_eq!(after["teams"]["fresh"]["leader_receiver"], previous_receiver);
+        assert_eq!(after["teams"]["fresh"]["owner_epoch"], json!(1));
+        assert_eq!(after.get("tasks"), Some(&json!({"keep": true})));
+        let _ = std::fs::remove_dir_all(&workspace);
+    }
+
+    #[test]
+    fn restore_exact_keeps_unmatched_winner() {
+        let workspace = workspace("restore-exact-winner");
+        let _ = persist_complete_normalized_baseline(&workspace);
+        let previous_uuid = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+        let previous_owner = complete_owner("%99", "codex", previous_uuid, 1);
+        let previous_receiver =
+            complete_receiver("%99", "codex", previous_uuid, 1, "/tmp/prev.sock");
+        commit_fresh_binding(&workspace, &previous_owner, &previous_receiver, 1);
+        let snapshot = super::BindingFileSnapshot::capture(
+            crate::state::persist::runtime_state_path(&workspace),
+        );
+        let this_uuid = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
+        let this_owner = complete_owner("%42", "codex", this_uuid, 1);
+        let this_receiver = complete_receiver(
+            "%42",
+            "codex",
+            this_uuid,
+            1,
+            "/private/tmp/tmux-test/default",
+        );
+        commit_fresh_binding(&workspace, &this_owner, &this_receiver, 1);
+        let this_receipt = (this_owner.clone(), this_receiver.clone());
+        let winner_uuid = "cccccccccccccccccccccccccccccccc";
+        let winner_owner = complete_owner("%7", "codex", winner_uuid, 2);
+        let winner_receiver = complete_receiver("%7", "codex", winner_uuid, 2, "/tmp/win.sock");
+        commit_fresh_binding(&workspace, &winner_owner, &winner_receiver, 2);
+        assert_ne!(
+            (winner_owner.clone(), winner_receiver.clone()),
+            this_receipt
+        );
+        super::restore_this_attempt_state(
+            &workspace,
+            "fresh",
+            Some(&snapshot),
+            Some(&this_receipt),
+            &[],
+        )
+        .unwrap();
+        let after = crate::state::persist::load_runtime_state(&workspace).unwrap();
+        assert_eq!(after["teams"]["fresh"]["team_owner"], winner_owner);
+        assert_eq!(after["teams"]["fresh"]["leader_receiver"], winner_receiver);
+        assert_eq!(after["teams"]["fresh"]["owner_epoch"], json!(2));
+        assert_ne!(after["teams"]["fresh"]["team_owner"], previous_owner);
+        assert_ne!(after["teams"]["fresh"]["leader_receiver"], previous_receiver);
+        let _ = std::fs::remove_dir_all(&workspace);
+    }
+
+    #[test]
+    fn readback_failure_rolls_back_exact_state_bytes() {
+        assert_failure_rolls_back_this_attempt(
+            "readback-failure-only",
+            MockOps {
+                readback_ok: false,
+                ..MockOps::default()
+            },
+            1,
+            1,
+            1,
+            true,
+        );
     }
 
     #[test]
@@ -2296,6 +3103,8 @@ mod fresh_quick_start_leader_binding_tests {
                     cas_conflict: false,
                     applied_grant: None,
                     registry_receipt: None,
+                    frozen_owner: None,
+                    frozen_receiver: None,
                     nonce_writer: None,
                 },
                 attached_provider: None,
@@ -2362,7 +3171,11 @@ mod fresh_quick_start_leader_binding_tests {
         }
     }
 
-    fn runtime_workspace(hermetic: &HermeticTestEnv, tag: &str) -> PathBuf {
+    fn runtime_workspace_with_provider(
+        hermetic: &HermeticTestEnv,
+        tag: &str,
+        provider: &str,
+    ) -> PathBuf {
         let path = hermetic.workspace(tag);
         crate::state::persist::save_runtime_state(
             &path,
@@ -2370,13 +3183,17 @@ mod fresh_quick_start_leader_binding_tests {
                 "active_team_key": "fresh",
                 "team_key": "fresh",
                 "session_name": "team-fresh",
-                "agents": {"sol": {"status": "running", "provider": "pi"}}
+                "agents": {"sol": {"status": "running", "provider": provider}}
             }),
         )
         .unwrap();
         path
     }
 
+    fn runtime_workspace(hermetic: &HermeticTestEnv, tag: &str) -> PathBuf {
+        runtime_workspace_with_provider(hermetic, tag, "codex")
+    }
+
     fn refusal_reason(workspace: &Path) -> Option<(String, String)> {
         let events = crate::event_log::EventLog::new(workspace).tail(0).unwrap();
         let event = events.last()?;
@@ -2429,23 +3246,169 @@ mod fresh_quick_start_leader_binding_tests {
         }
     }
 
+    fn bind_seeded_caller(target: PaneInfo, hermetic_name: &str) -> (bool, Option<&'static str>) {
+        let hermetic = HermeticTestEnv::enter(hermetic_name);
+        let workspace = runtime_workspace(&hermetic, "fresh");
+        let _tmux = hermetic.with_env("TMUX", "/tmp/tmux.sock,1,0");
+        let _pane = hermetic.with_env("TMUX_PANE", "%1");
+        let _provider = hermetic.with_env(CALLER_PROVIDER_ENV, "codex");
+        let _caller_pane = hermetic.with_env(CALLER_PANE_ENV, "%1");
+        let _caller_endpoint = hermetic.with_env(CALLER_ENDPOINT_ENV, "/tmp/tmux.sock");
+        let seed = seeded_runtime_owner(&workspace);
+        let transport = OfflineTransport::new()
+            .with_tmux_endpoint("/tmp/tmux.sock")
+            .with_pane_current_command("%1", "bash")
+            .with_targets(vec![target]);
+        let mut ops = RuntimeFreshQuickStartLeaderBindingOps {
+            transport: &transport,
+            last_failure_reason: None,
+            cas_conflict: false,
+            applied_grant: None,
+            registry_receipt: None,
+            frozen_owner: None,
+            frozen_receiver: None,
+            nonce_writer: None,
+        };
+        let ok = crate::transport_factory::with_leader_endpoint_transport(
+            "/tmp/tmux.sock",
+            transport.clone(),
+            || bind_fresh_quick_start_leader_with(&workspace, "fresh", Some(&seed), &mut ops),
+        )
+        .unwrap();
+        (ok, ops.last_failure_reason)
+    }
+
     #[test]
     #[serial_test::serial(env)]
-    fn runtime_valid_caller_binds_typed_pi_through_bash() {
-        let hermetic = HermeticTestEnv::enter("runtime-valid-pi-bash");
+    fn seeded_runtime_bind_ignores_pane_focus_for_same_live_caller() {
+        let parent = std::env::temp_dir().join(format!(
+            "ta-inactive-cwd-{}-{}",
+            std::process::id(),
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap()
+                .as_nanos()
+        ));
+        std::fs::create_dir_all(&parent).unwrap();
+        let mut focused = caller_target(parent.clone(), Some("shared-live-nonce"));
+        focused.active = true;
+        let (active_ok, active_reason) = bind_seeded_caller(focused, "runtime-focus-active");
+        assert!(active_ok, "focused live caller must bind: {active_reason:?}");
+
+        let mut background = caller_target(parent, Some("shared-live-nonce"));
+        background.active = false;
+        let (inactive_ok, inactive_reason) =
+            bind_seeded_caller(background, "runtime-focus-inactive");
+        assert!(
+            inactive_ok,
+            "same live caller with pane_active=0 must still bind: {inactive_reason:?}"
+        );
+    }
+
+    #[test]
+    #[serial_test::serial(env)]
+    fn seeded_runtime_bind_dead_pane_still_refuses() {
+        let hermetic = HermeticTestEnv::enter("runtime-dead-pane");
         let workspace = runtime_workspace(&hermetic, "fresh");
         let _tmux = hermetic.with_env("TMUX", "/tmp/tmux.sock,1,0");
         let _pane = hermetic.with_env("TMUX_PANE", "%1");
-        let _provider = hermetic.with_env(CALLER_PROVIDER_ENV, "pi");
+        let _provider = hermetic.with_env(CALLER_PROVIDER_ENV, "codex");
         let _caller_pane = hermetic.with_env(CALLER_PANE_ENV, "%1");
         let _caller_endpoint = hermetic.with_env(CALLER_ENDPOINT_ENV, "/tmp/tmux.sock");
+        let seed = seeded_runtime_owner(&workspace);
         let transport = OfflineTransport::new()
             .with_tmux_endpoint("/tmp/tmux.sock")
             .with_pane_current_command("%1", "bash");
-        let mut ops = RecordingRuntimeOps::new(&transport);
-        assert!(bind_fresh_quick_start_leader_with(&workspace, "fresh", None, &mut ops).unwrap());
-        assert_eq!(ops.attached_provider, Some(crate::provider::Provider::Pi));
-        assert_eq!(ops.attach_calls, 1);
+        let mut ops = RuntimeFreshQuickStartLeaderBindingOps {
+            transport: &transport,
+            last_failure_reason: None,
+            cas_conflict: false,
+            applied_grant: None,
+            registry_receipt: None,
+            frozen_owner: None,
+            frozen_receiver: None,
+            nonce_writer: None,
+        };
+        assert!(!bind_fresh_quick_start_leader_with(&workspace, "fresh", Some(&seed), &mut ops)
+            .unwrap());
+        assert_eq!(ops.last_failure_reason, Some("caller_pane_not_live"));
+    }
+
+    #[test]
+    #[serial_test::serial(env)]
+    fn seeded_runtime_bind_identity_mismatch_still_refuses() {
+        let parent = std::env::temp_dir().join(format!(
+            "ta-mismatch-cwd-{}-{}",
+            std::process::id(),
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap()
+                .as_nanos()
+        ));
+        std::fs::create_dir_all(&parent).unwrap();
+        let mut other_pane = caller_target(parent, Some("shared-live-nonce"));
+        other_pane.pane_id = PaneId::new("%9");
+        let (ok, reason) = bind_seeded_caller(other_pane, "runtime-identity-mismatch");
+        assert!(!ok);
+        assert_eq!(reason, Some("caller_pane_not_live"));
+    }
+
+    #[test]
+    fn existing_runtime_view_uses_requested_bob_not_top_level_alice() {
+        let state = json!({
+            "agents": { "alice": { "window": "alice" } },
+            "session_name": "team-alice",
+            "tmux_endpoint": "/tmp/shared.sock",
+            "teams": {
+                "alice": {
+                    "agents": { "alice": { "window": "alice" } },
+                    "session_name": "team-alice"
+                },
+                "bob": {
+                    "agents": { "bob": { "window": "bob" } },
+                    "session_name": "team-bob"
+                }
+            }
+        });
+        let view = existing_runtime_identity_view(&state, Some("bob"));
+        let ids = view
+            .get("agents")
+            .and_then(serde_json::Value::as_object)
+            .map(|agents| agents.keys().cloned().collect::<Vec<_>>())
+            .unwrap_or_default();
+        assert_eq!(ids, vec!["bob".to_string()]);
+        assert_eq!(view.get("session_name").and_then(serde_json::Value::as_str), Some("team-bob"));
+    }
+
+    #[test]
+    fn existing_runtime_view_empty_top_level_agents_still_emits_bob() {
+        let state = json!({
+            "agents": {},
+            "teams": {
+                "bob": {
+                    "agents": { "bob": { "window": "bob" } },
+                    "session_name": "team-bob"
+                }
+            }
+        });
+        let view = existing_runtime_identity_view(&state, Some("bob"));
+        assert!(view
+            .get("agents")
+            .and_then(serde_json::Value::as_object)
+            .is_some_and(|agents| agents.contains_key("bob")));
+    }
+
+    #[test]
+    fn existing_runtime_view_legacy_root_without_teams_map() {
+        let state = json!({
+            "agents": { "alice": { "window": "alice" } },
+            "session_name": "team-alice"
+        });
+        let view = existing_runtime_identity_view(&state, Some("alice"));
+        assert!(view
+            .get("agents")
+            .and_then(serde_json::Value::as_object)
+            .is_some_and(|agents| agents.contains_key("alice")));
     }
 
     #[test]
@@ -2457,7 +3420,7 @@ mod fresh_quick_start_leader_binding_tests {
         std::fs::create_dir_all(&parent).unwrap();
         let _tmux = hermetic.with_env("TMUX", "/tmp/tmux.sock,1,0");
         let _pane = hermetic.with_env("TMUX_PANE", "%1");
-        let _provider = hermetic.with_env(CALLER_PROVIDER_ENV, "pi");
+        let _provider = hermetic.with_env(CALLER_PROVIDER_ENV, "codex");
         let _caller_pane = hermetic.with_env(CALLER_PANE_ENV, "%1");
         let _caller_endpoint = hermetic.with_env(CALLER_ENDPOINT_ENV, "/tmp/tmux.sock");
         let seed = seeded_runtime_owner(&workspace);
@@ -2471,14 +3434,15 @@ mod fresh_quick_start_leader_binding_tests {
             last_failure_reason: None,
             cas_conflict: false,
             applied_grant: None,
-            registry_receipt: None,
-            nonce_writer: None,
-        };
-        assert!(bind_fresh_quick_start_leader_with(
-            &workspace,
-            "fresh",
-            Some(&seed),
-            &mut ops
+            registry_receipt: None,
+            frozen_owner: None,
+            frozen_receiver: None,
+            nonce_writer: None,
+        };
+        assert!(crate::transport_factory::with_leader_endpoint_transport(
+            "/tmp/tmux.sock",
+            transport.clone(),
+            || bind_fresh_quick_start_leader_with(&workspace, "fresh", Some(&seed), &mut ops)
         )
         .unwrap());
         let persisted = crate::state::persist::load_runtime_state(&workspace).unwrap();
@@ -2588,7 +3552,7 @@ mod fresh_quick_start_leader_binding_tests {
         let hermetic = HermeticTestEnv::enter("runtime-seeded-shared-nonce");
         let _tmux = hermetic.with_env("TMUX", "/tmp/tmux.sock,1,0");
         let _pane = hermetic.with_env("TMUX_PANE", "%1");
-        let _provider = hermetic.with_env(CALLER_PROVIDER_ENV, "pi");
+        let _provider = hermetic.with_env(CALLER_PROVIDER_ENV, "codex");
         let _caller_pane = hermetic.with_env(CALLER_PANE_ENV, "%1");
         let _caller_endpoint = hermetic.with_env(CALLER_ENDPOINT_ENV, "/tmp/tmux.sock");
         let parent = hermetic.root().join("parent");
@@ -2599,12 +3563,7 @@ mod fresh_quick_start_leader_binding_tests {
             .with_tmux_endpoint("/tmp/tmux.sock")
             .with_pane_current_command("%1", "bash")
             .with_targets(vec![target_with_winner.clone()])
-            .with_target_snapshots(vec![
-                vec![target_without_nonce.clone()],
-                vec![target_with_winner.clone()],
-                vec![target_without_nonce],
-                vec![target_with_winner],
-            ]);
+            .with_target_snapshots(vec![vec![target_without_nonce]]);
         let first_workspace = runtime_workspace(&hermetic, "child-a");
         let second_workspace = runtime_workspace(&hermetic, "child-b");
         let first_seed = seeded_runtime_owner(&first_workspace);
@@ -2615,13 +3574,19 @@ mod fresh_quick_start_leader_binding_tests {
             cas_conflict: false,
             applied_grant: None,
             registry_receipt: None,
+            frozen_owner: None,
+            frozen_receiver: None,
             nonce_writer: Some(&nonce_writer_winner),
         };
-        assert!(bind_fresh_quick_start_leader_with(
-            &first_workspace,
-            "fresh",
-            Some(&first_seed),
-            &mut first_ops
+        assert!(crate::transport_factory::with_leader_endpoint_transport(
+            "/tmp/tmux.sock",
+            transport.clone(),
+            || bind_fresh_quick_start_leader_with(
+                &first_workspace,
+                "fresh",
+                Some(&first_seed),
+                &mut first_ops
+            )
         )
         .unwrap());
         let mut second_ops = RuntimeFreshQuickStartLeaderBindingOps {
@@ -2630,13 +3595,19 @@ mod fresh_quick_start_leader_binding_tests {
             cas_conflict: false,
             applied_grant: None,
             registry_receipt: None,
+            frozen_owner: None,
+            frozen_receiver: None,
             nonce_writer: Some(&nonce_writer_winner),
         };
-        assert!(bind_fresh_quick_start_leader_with(
-            &second_workspace,
-            "fresh",
-            Some(&second_seed),
-            &mut second_ops
+        assert!(crate::transport_factory::with_leader_endpoint_transport(
+            "/tmp/tmux.sock",
+            transport.clone(),
+            || bind_fresh_quick_start_leader_with(
+                &second_workspace,
+                "fresh",
+                Some(&second_seed),
+                &mut second_ops
+            )
         )
         .unwrap());
         let first_receiver = crate::state::persist::load_runtime_state(&first_workspace).unwrap();
@@ -2786,7 +3757,7 @@ mod fresh_quick_start_leader_binding_tests {
         std::fs::create_dir_all(&parent).unwrap();
         let _tmux = hermetic.with_env("TMUX", "/tmp/tmux.sock,1,0");
         let _pane = hermetic.with_env("TMUX_PANE", "%1");
-        let _provider = hermetic.with_env(CALLER_PROVIDER_ENV, "pi");
+        let _provider = hermetic.with_env(CALLER_PROVIDER_ENV, "codex");
         let _caller_pane = hermetic.with_env(CALLER_PANE_ENV, "%1");
         let _caller_endpoint = hermetic.with_env(CALLER_ENDPOINT_ENV, "/tmp/tmux.sock");
         let seed = seeded_runtime_owner(&workspace);
@@ -2807,6 +3778,8 @@ mod fresh_quick_start_leader_binding_tests {
                 cas_conflict: false,
                 applied_grant: None,
                 registry_receipt: None,
+                frozen_owner: None,
+                frozen_receiver: None,
                 nonce_writer: Some(&nonce_writer_winner),
             },
             register_ok: false,
@@ -2858,7 +3831,7 @@ mod fresh_quick_start_leader_binding_tests {
         std::fs::create_dir_all(&parent).unwrap();
         let _tmux = hermetic.with_env("TMUX", "/tmp/tmux.sock,1,0");
         let _pane = hermetic.with_env("TMUX_PANE", "%1");
-        let _provider = hermetic.with_env(CALLER_PROVIDER_ENV, "pi");
+        let _provider = hermetic.with_env(CALLER_PROVIDER_ENV, "codex");
         let _caller_pane = hermetic.with_env(CALLER_PANE_ENV, "%1");
         let _caller_endpoint = hermetic.with_env(CALLER_ENDPOINT_ENV, "/tmp/tmux.sock");
         let seed = seeded_runtime_owner(&workspace);
@@ -2874,6 +3847,8 @@ mod fresh_quick_start_leader_binding_tests {
                 cas_conflict: false,
                 applied_grant: None,
                 registry_receipt: None,
+                frozen_owner: None,
+                frozen_receiver: None,
                 nonce_writer: None,
             },
             register_ok: true,
@@ -2917,7 +3892,7 @@ mod fresh_quick_start_leader_binding_tests {
         std::fs::create_dir_all(&parent).unwrap();
         let _tmux = hermetic.with_env("TMUX", "/tmp/tmux.sock,1,0");
         let _pane = hermetic.with_env("TMUX_PANE", "%1");
-        let _provider = hermetic.with_env(CALLER_PROVIDER_ENV, "pi");
+        let _provider = hermetic.with_env(CALLER_PROVIDER_ENV, "codex");
         let _caller_pane = hermetic.with_env(CALLER_PANE_ENV, "%1");
         let _caller_endpoint = hermetic.with_env(CALLER_ENDPOINT_ENV, "/tmp/tmux.sock");
         let seed = seeded_runtime_owner(&workspace);
@@ -2937,13 +3912,14 @@ mod fresh_quick_start_leader_binding_tests {
             cas_conflict: false,
             applied_grant: None,
             registry_receipt: None,
+            frozen_owner: None,
+            frozen_receiver: None,
             nonce_writer: None,
         };
-        assert!(!bind_fresh_quick_start_leader_with(
-            &workspace,
-            "fresh",
-            Some(&seed),
-            &mut ops
+        assert!(!crate::transport_factory::with_leader_endpoint_transport(
+            "/tmp/tmux.sock",
+            transport.clone(),
+            || bind_fresh_quick_start_leader_with(&workspace, "fresh", Some(&seed), &mut ops)
         )
         .unwrap());
         assert_eq!(ops.last_failure_reason, Some("receiver_live_channel_unavailable"));
@@ -2972,7 +3948,7 @@ mod fresh_quick_start_leader_binding_tests {
         std::fs::create_dir_all(&parent).unwrap();
         let _tmux = hermetic.with_env("TMUX", "/tmp/tmux.sock,1,0");
         let _pane = hermetic.with_env("TMUX_PANE", "%1");
-        let _provider = hermetic.with_env(CALLER_PROVIDER_ENV, "pi");
+        let _provider = hermetic.with_env(CALLER_PROVIDER_ENV, "codex");
         let _caller_pane = hermetic.with_env(CALLER_PANE_ENV, "%1");
         let _caller_endpoint = hermetic.with_env(CALLER_ENDPOINT_ENV, "/tmp/tmux.sock");
         let seed = seeded_runtime_owner(&workspace);
@@ -2988,6 +3964,8 @@ mod fresh_quick_start_leader_binding_tests {
                 cas_conflict: false,
                 applied_grant: None,
                 registry_receipt: None,
+                frozen_owner: None,
+                frozen_receiver: None,
                 nonce_writer: None,
             },
             register_ok: true,
@@ -3029,7 +4007,7 @@ mod fresh_quick_start_leader_binding_tests {
         std::fs::create_dir_all(&parent).unwrap();
         let _tmux = hermetic.with_env("TMUX", "/tmp/tmux.sock,1,0");
         let _pane = hermetic.with_env("TMUX_PANE", "%1");
-        let _provider = hermetic.with_env(CALLER_PROVIDER_ENV, "pi");
+        let _provider = hermetic.with_env(CALLER_PROVIDER_ENV, "codex");
         let _caller_pane = hermetic.with_env(CALLER_PANE_ENV, "%1");
         let _caller_endpoint = hermetic.with_env(CALLER_ENDPOINT_ENV, "/tmp/tmux.sock");
         let seed = seeded_runtime_owner(&workspace);
@@ -3045,6 +4023,8 @@ mod fresh_quick_start_leader_binding_tests {
                 cas_conflict: false,
                 applied_grant: None,
                 registry_receipt: None,
+                frozen_owner: None,
+                frozen_receiver: None,
                 nonce_writer: None,
             },
             register_ok: true,
@@ -3110,7 +4090,7 @@ mod fresh_quick_start_leader_binding_tests {
             std::fs::create_dir_all(&parent).unwrap();
             let _tmux = hermetic.with_env("TMUX", "/tmp/tmux.sock,1,0");
             let _pane = hermetic.with_env("TMUX_PANE", "%1");
-            let _provider = hermetic.with_env(CALLER_PROVIDER_ENV, "pi");
+            let _provider = hermetic.with_env(CALLER_PROVIDER_ENV, "codex");
             let _caller_pane = hermetic.with_env(CALLER_PANE_ENV, "%1");
             let _caller_endpoint = hermetic.with_env(CALLER_ENDPOINT_ENV, "/tmp/tmux.sock");
             let seed = seeded_runtime_owner(&workspace);
@@ -3126,6 +4106,8 @@ mod fresh_quick_start_leader_binding_tests {
                     cas_conflict: false,
                     applied_grant: None,
                     registry_receipt: None,
+                    frozen_owner: None,
+                    frozen_receiver: None,
                     nonce_writer: None,
                 },
                 register_ok: true,
@@ -3188,7 +4170,7 @@ mod fresh_quick_start_leader_binding_tests {
             std::fs::create_dir_all(&parent).unwrap();
             let _tmux = hermetic.with_env("TMUX", "/tmp/tmux.sock,1,0");
             let _pane = hermetic.with_env("TMUX_PANE", "%1");
-            let _provider = hermetic.with_env(CALLER_PROVIDER_ENV, "pi");
+            let _provider = hermetic.with_env(CALLER_PROVIDER_ENV, "codex");
             let _caller_pane = hermetic.with_env(CALLER_PANE_ENV, "%1");
             let _caller_endpoint = hermetic.with_env(CALLER_ENDPOINT_ENV, "/tmp/tmux.sock");
             let seed = seeded_runtime_owner(&workspace);
@@ -3213,6 +4195,8 @@ mod fresh_quick_start_leader_binding_tests {
                 cas_conflict: false,
                 applied_grant: None,
                 registry_receipt: None,
+                frozen_owner: None,
+                frozen_receiver: None,
                 nonce_writer: None,
             };
             assert!(!bind_fresh_quick_start_leader_with(
@@ -3236,14 +4220,14 @@ mod fresh_quick_start_leader_binding_tests {
 
     #[test]
     #[serial_test::serial(env)]
-    fn first_nonce_writer_is_product_generated_and_consumer_live() {
+    fn first_nonce_writer_is_product_generated_and_consumer_live_provider_independent() {
         let hermetic = HermeticTestEnv::enter("runtime-first-nonce-writer");
         let workspace = runtime_workspace(&hermetic, "fresh");
         let parent = hermetic.root().join("parent");
         std::fs::create_dir_all(&parent).unwrap();
         let _tmux = hermetic.with_env("TMUX", "/tmp/tmux.sock,1,0");
         let _pane = hermetic.with_env("TMUX_PANE", "%1");
-        let _provider = hermetic.with_env(CALLER_PROVIDER_ENV, "pi");
+        let _provider = hermetic.with_env(CALLER_PROVIDER_ENV, "codex");
         let _caller_pane = hermetic.with_env(CALLER_PANE_ENV, "%1");
         let _caller_endpoint = hermetic.with_env(CALLER_ENDPOINT_ENV, "/tmp/tmux.sock");
         let seed = seeded_runtime_owner(&workspace);
@@ -3261,7 +4245,7 @@ mod fresh_quick_start_leader_binding_tests {
             &workspace,
             &mut state,
             Some(&PaneId::new("%1")),
-            crate::provider::Provider::Pi,
+            crate::provider::Provider::Codex,
             &event_log,
             crate::leader::LeaseSource::QuickStart,
             true,
@@ -3297,7 +4281,7 @@ mod fresh_quick_start_leader_binding_tests {
             &workspace,
             &mut state,
             Some(&PaneId::new("%1")),
-            crate::provider::Provider::Pi,
+            crate::provider::Provider::Codex,
             &crate::event_log::EventLog::new(&workspace),
             crate::leader::LeaseSource::QuickStart,
             true,
@@ -3325,7 +4309,7 @@ mod fresh_quick_start_leader_binding_tests {
         std::fs::create_dir_all(&parent).unwrap();
         let _tmux = hermetic.with_env("TMUX", "/tmp/tmux.sock,1,0");
         let _pane = hermetic.with_env("TMUX_PANE", "%1");
-        let _provider = hermetic.with_env(CALLER_PROVIDER_ENV, "pi");
+        let _provider = hermetic.with_env(CALLER_PROVIDER_ENV, "codex");
         let _caller_pane = hermetic.with_env(CALLER_PANE_ENV, "%1");
         let _caller_endpoint = hermetic.with_env(CALLER_ENDPOINT_ENV, "/tmp/tmux.sock");
         let seed = seeded_runtime_owner(&workspace);
@@ -3361,6 +4345,8 @@ mod fresh_quick_start_leader_binding_tests {
             cas_conflict: false,
             applied_grant: None,
             registry_receipt: None,
+            frozen_owner: None,
+            frozen_receiver: None,
             nonce_writer: Some(&concurrent_writer),
         };
         assert!(!bind_fresh_quick_start_leader_with(
@@ -3401,32 +4387,6 @@ mod fresh_quick_start_leader_binding_tests {
         assert_eq!(winner_entry.channel["pane_id"], json!("%winner"));
     }
 
-    #[test]
-    #[serial_test::serial(env)]
-    fn runtime_invalid_caller_refuses_even_when_command_is_pi() {
-        let hermetic = HermeticTestEnv::enter("runtime-invalid-command-pi");
-        let workspace = runtime_workspace(&hermetic, "fresh");
-        let _tmux = hermetic.with_env("TMUX", "/tmp/tmux.sock,1,0");
-        let _pane = hermetic.with_env("TMUX_PANE", "%1");
-        let _provider = hermetic.with_env(CALLER_PROVIDER_ENV, "pi");
-        let _caller_pane = hermetic.with_env(CALLER_PANE_ENV, "%9");
-        let _caller_endpoint = hermetic.with_env(CALLER_ENDPOINT_ENV, "/tmp/tmux.sock");
-        let transport = OfflineTransport::new()
-            .with_tmux_endpoint("/tmp/tmux.sock")
-            .with_pane_current_command("%1", "pi");
-        let mut ops = RecordingRuntimeOps::new(&transport);
-        assert!(!bind_fresh_quick_start_leader_with(&workspace, "fresh", None, &mut ops).unwrap());
-        assert_eq!(ops.attach_calls, 0);
-        assert_eq!(ops.attached_provider, None);
-        assert_eq!(
-            refusal_reason(&workspace),
-            Some((
-                "strict_provider".to_string(),
-                "provider_unresolved".to_string()
-            ))
-        );
-    }
-
     #[test]
     #[serial_test::serial(env)]
     fn runtime_socket_and_explicit_conflicts_refuse_without_command_fallback() {
@@ -3444,9 +4404,11 @@ mod fresh_quick_start_leader_binding_tests {
                 "/tmp/product.sock",
             ),
             (
+                // The explicit leader provider intentionally conflicts with the
+                // caller provider; worker_env must reject this before command fallback.
                 "leader",
                 "/tmp/tmux.sock",
-                Some("codex"),
+                Some("claude"),
                 "/tmp/tmux.sock",
             ),
         ] {
@@ -3454,13 +4416,13 @@ mod fresh_quick_start_leader_binding_tests {
             let workspace = runtime_workspace(&hermetic, tag);
             let _tmux = hermetic.with_env("TMUX", "/tmp/tmux.sock,1,0");
             let _pane = hermetic.with_env("TMUX_PANE", "%1");
-            let _provider = hermetic.with_env(CALLER_PROVIDER_ENV, "pi");
+            let _provider = hermetic.with_env(CALLER_PROVIDER_ENV, "codex");
             let _caller_pane = hermetic.with_env(CALLER_PANE_ENV, "%1");
             let _caller_endpoint = hermetic.with_env(CALLER_ENDPOINT_ENV, endpoint);
             let _leader = leader.map(|value| hermetic.with_env("TEAM_AGENT_LEADER_PROVIDER", value));
             let transport = OfflineTransport::new()
                 .with_tmux_endpoint(scoped)
-                .with_pane_current_command("%1", "pi");
+                .with_pane_current_command("%1", "codex");
             let mut ops = RecordingRuntimeOps::new(&transport);
             assert!(
                 !bind_fresh_quick_start_leader_with(&workspace, "fresh", None, &mut ops).unwrap(),
@@ -3470,11 +4432,216 @@ mod fresh_quick_start_leader_binding_tests {
         }
     }
 
+
+    #[test]
+    fn invalid_pi_tool_category_is_rejected_before_runtime_persistence() {
+        let root = std::env::temp_dir().join(format!(
+            "ta-quick-start-pi-tools-{}-{}",
+            std::process::id(),
+            SEQUENCE.fetch_add(1, Ordering::Relaxed)
+        ));
+        let team = root.join(".team/current");
+        std::fs::create_dir_all(team.join("agents")).unwrap();
+        std::fs::write(
+            team.join("TEAM.md"),
+            "---\nname: pi-tools\nprovider: pi\n---\n\nPi team.\n",
+        )
+        .unwrap();
+        std::fs::write(
+            team.join("agents/worker.md"),
+            "---\nname: worker\nrole: Worker\nprovider: pi\nauth_mode: subscription\ndangerously_skip_permissions: false\ntools:\n  - mcp_team\n  - fs_read\n  - provider_builtin\n---\n\nWorker.\n",
+        )
+        .unwrap();
+
+        let transport = crate::transport::test_support::OfflineTransport::new();
+        let mut discover = |_requested: &str| -> Result<Vec<String>, ()> { Err(()) };
+        let error = quick_start_with_transport_in_workspace_with_display_pi_preflight(
+            &root,
+            &team,
+            None,
+            true,
+            None,
+            &transport,
+            false,
+            &mut discover,
+        )
+        .expect_err("invalid Pi category must fail before quick-start persistence");
+        let error = error.to_string();
+        assert!(error.contains("Pi does not support Team Agent tool category \"provider_builtin\""));
+        assert!(error.contains("remove it from the role's tools"));
+        assert!(
+            !crate::state::persist::runtime_state_path(&root).exists(),
+            "quick-start validation failure must not persist runtime state"
+        );
+        assert!(
+            !root.join(".team/runtime").exists(),
+            "quick-start validation failure must not create runtime artifacts"
+        );
+        let _ = std::fs::remove_dir_all(root);
+    }
+
+    #[test]
+    fn fresh_binding_persists_then_registers_then_requires_canonical_readback() {
+        let workspace = workspace_with_provider("positive-pi", "pi");
+        let mut ops = MockOps::with_provider("pi");
+        assert!(bind_fresh_quick_start_leader_with(&workspace, "fresh", None, &mut ops)
+            .unwrap());
+        assert_eq!(ops.attached_provider, Some(crate::provider::Provider::Pi));
+        assert_eq!(ops.attach_calls, 1);
+        assert_eq!(ops.register_calls, 1);
+        assert_eq!(ops.readback_calls, 1);
+        let state = crate::state::persist::load_runtime_state(&workspace).unwrap();
+        assert_eq!(
+            state
+                .get("teams")
+                .and_then(serde_json::Value::as_object)
+                .and_then(|teams| teams.get("fresh"))
+                .and_then(|team| team.get("leader_receiver"))
+                .and_then(|receiver| receiver.get("pane_id"))
+                .and_then(serde_json::Value::as_str),
+            Some("%42")
+        );
+        assert!(
+            crate::event_log::EventLog::new(&workspace)
+                .tail(0)
+                .unwrap()
+                .is_empty(),
+            "successful bind must not emit a refusal event"
+        );
+    }
+
+    #[test]
+    #[serial_test::serial(env)]
+    fn runtime_valid_caller_binds_typed_pi_through_bash() {
+        let hermetic = HermeticTestEnv::enter("runtime-valid-pi-bash");
+        let workspace = runtime_workspace_with_provider(&hermetic, "fresh", "pi");
+        let _tmux = hermetic.with_env("TMUX", "/tmp/tmux.sock,1,0");
+        let _pane = hermetic.with_env("TMUX_PANE", "%1");
+        let _provider = hermetic.with_env(CALLER_PROVIDER_ENV, "pi");
+        let _caller_pane = hermetic.with_env(CALLER_PANE_ENV, "%1");
+        let _caller_endpoint = hermetic.with_env(CALLER_ENDPOINT_ENV, "/tmp/tmux.sock");
+        let transport = OfflineTransport::new()
+            .with_tmux_endpoint("/tmp/tmux.sock")
+            .with_pane_current_command("%1", "bash");
+        let mut ops = RecordingRuntimeOps::new(&transport);
+        assert!(bind_fresh_quick_start_leader_with(&workspace, "fresh", None, &mut ops).unwrap());
+        assert_eq!(ops.attached_provider, Some(crate::provider::Provider::Pi));
+        assert_eq!(ops.attach_calls, 1);
+    }
+
+    #[test]
+    #[serial_test::serial(env)]
+    fn first_nonce_writer_is_product_generated_and_consumer_live() {
+        let hermetic = HermeticTestEnv::enter("runtime-first-nonce-writer");
+        let workspace = runtime_workspace_with_provider(&hermetic, "fresh", "pi");
+        let parent = hermetic.root().join("parent");
+        std::fs::create_dir_all(&parent).unwrap();
+        let _tmux = hermetic.with_env("TMUX", "/tmp/tmux.sock,1,0");
+        let _pane = hermetic.with_env("TMUX_PANE", "%1");
+        let _provider = hermetic.with_env(CALLER_PROVIDER_ENV, "pi");
+        let _caller_pane = hermetic.with_env(CALLER_PANE_ENV, "%1");
+        let _caller_endpoint = hermetic.with_env(CALLER_ENDPOINT_ENV, "/tmp/tmux.sock");
+        let seed = seeded_runtime_owner(&workspace);
+        let mut state = crate::state::projection::resolve_runtime_team_scope(
+            &workspace,
+            Some("fresh"),
+        )
+        .unwrap()
+        .state;
+        let expected_owner = state["team_owner"].clone();
+        let expected_receiver = state["leader_receiver"].clone();
+        let target = caller_target(parent.clone(), None);
+        let event_log = crate::event_log::EventLog::new(&workspace);
+        let (receiver, _) = crate::leader::attach_leader_to_state_with_target_and_controls(
+            &workspace,
+            &mut state,
+            Some(&PaneId::new("%1")),
+            crate::provider::Provider::Pi,
+            &event_log,
+            crate::leader::LeaseSource::QuickStart,
+            true,
+            Some(&target),
+            Some(&expected_owner),
+            Some(&expected_receiver),
+            Some(&nonce_writer_winner),
+        )
+        .unwrap();
+        let receiver = serde_json::to_value(receiver).unwrap();
+        assert_eq!(receiver["binding_nonce"], json!("writer-winner"));
+        let observed = caller_target(parent, Some("writer-winner"));
+        let transport = OfflineTransport::new()
+            .with_tmux_endpoint("/tmp/tmux.sock")
+            .with_targets(vec![observed]);
+        assert!(matches!(
+            crate::messaging::resolve_live_leader_channel(&workspace, &receiver, &transport),
+            crate::messaging::LeaderChannelResolution::Live(_)
+        ));
+
+        let workspace = runtime_workspace_with_provider(&hermetic, "writer-failure", "pi");
+        let seed = seeded_runtime_owner(&workspace);
+        let mut state = crate::state::projection::resolve_runtime_team_scope(
+            &workspace,
+            Some("fresh"),
+        )
+        .unwrap()
+        .state;
+        let expected_owner = state["team_owner"].clone();
+        let expected_receiver = state["leader_receiver"].clone();
+        let target = caller_target(hermetic.root().join("parent"), None);
+        let result = crate::leader::attach_leader_to_state_with_target_and_controls(
+            &workspace,
+            &mut state,
+            Some(&PaneId::new("%1")),
+            crate::provider::Provider::Pi,
+            &crate::event_log::EventLog::new(&workspace),
+            crate::leader::LeaseSource::QuickStart,
+            true,
+            Some(&target),
+            Some(&expected_owner),
+            Some(&expected_receiver),
+            Some(&nonce_writer_failure),
+        );
+        assert!(result.is_err());
+        let persisted = crate::state::persist::load_runtime_state(&workspace).unwrap();
+        assert_eq!(
+            persisted.pointer("/teams/fresh/leader_receiver/binding_nonce"),
+            None
+        );
+        assert!(!persisted.to_string().contains("fresh_caller"));
+        let _ = seed;
+    }
+
+    #[test]
+    #[serial_test::serial(env)]
+    fn runtime_invalid_caller_refuses_even_when_command_is_pi() {
+        let hermetic = HermeticTestEnv::enter("runtime-invalid-command-pi");
+        let workspace = runtime_workspace_with_provider(&hermetic, "fresh", "pi");
+        let _tmux = hermetic.with_env("TMUX", "/tmp/tmux.sock,1,0");
+        let _pane = hermetic.with_env("TMUX_PANE", "%1");
+        let _provider = hermetic.with_env(CALLER_PROVIDER_ENV, "pi");
+        let _caller_pane = hermetic.with_env(CALLER_PANE_ENV, "%9");
+        let _caller_endpoint = hermetic.with_env(CALLER_ENDPOINT_ENV, "/tmp/tmux.sock");
+        let transport = OfflineTransport::new()
+            .with_tmux_endpoint("/tmp/tmux.sock")
+            .with_pane_current_command("%1", "pi");
+        let mut ops = RecordingRuntimeOps::new(&transport);
+        assert!(!bind_fresh_quick_start_leader_with(&workspace, "fresh", None, &mut ops).unwrap());
+        assert_eq!(ops.attach_calls, 0);
+        assert_eq!(ops.attached_provider, None);
+        assert_eq!(
+            refusal_reason(&workspace),
+            Some((
+                "strict_provider".to_string(),
+                "invalid_caller_tuple".to_string()
+            ))
+        );
+    }
+
     #[test]
     #[serial_test::serial(env)]
     fn runtime_absent_keeps_explicit_and_direct_paths() {
         let hermetic = HermeticTestEnv::enter("runtime-absent-compat");
-        let workspace = runtime_workspace(&hermetic, "explicit");
+        let workspace = runtime_workspace_with_provider(&hermetic, "explicit", "pi");
         let _tmux = hermetic.with_env("TMUX", "/tmp/tmux.sock,1,0");
         let _pane = hermetic.with_env("TMUX_PANE", "%1");
         let _leader = hermetic.with_env("TEAM_AGENT_LEADER_PROVIDER", "pi");
@@ -3485,7 +4652,7 @@ mod fresh_quick_start_leader_binding_tests {
         assert!(bind_fresh_quick_start_leader_with(&workspace, "fresh", None, &mut ops).unwrap());
         assert_eq!(ops.attached_provider, Some(crate::provider::Provider::Pi));
 
-        let workspace = runtime_workspace(&hermetic, "direct");
+        let workspace = runtime_workspace_with_provider(&hermetic, "direct", "pi");
         drop(_leader);
         let transport = OfflineTransport::new()
             .with_tmux_endpoint("/tmp/tmux.sock")
@@ -3494,7 +4661,7 @@ mod fresh_quick_start_leader_binding_tests {
         assert!(bind_fresh_quick_start_leader_with(&workspace, "fresh", None, &mut ops).unwrap());
         assert_eq!(ops.attached_provider, Some(crate::provider::Provider::Pi));
 
-        let workspace = runtime_workspace(&hermetic, "unknown-shell");
+        let workspace = runtime_workspace_with_provider(&hermetic, "unknown-shell", "pi");
         let transport = OfflineTransport::new()
             .with_tmux_endpoint("/tmp/tmux.sock")
             .with_pane_current_command("%1", "bash");