@team-agent/installer 0.5.113 → 0.5.115

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

@@ -23,7 +23,7 @@ use crate::provider::{get_adapter, Provider};
 use crate::tmux_backend::TmuxBackend;
 use crate::transport::{
     CaptureRange, PaneId, PaneInfo, PaneLiveness, SessionName, SpawnResult, Target, Transport,
-    WindowName,
+    TransportError, WindowName,
 };
 
 use super::helpers::{
@@ -291,6 +291,13 @@ fn leader_start_plan_with_ambient_authority(
         ),
         _ => None,
     };
+    let configured_prompt = if mode == LeaderStartMode::AttachExisting {
+        None
+    } else {
+        super::prompt::load().map_err(|error| error.for_provider(provider))?
+    };
+    let mut pi_routed_argv = None;
+    let mut session_capture = None;
     let mut provider_argv = if provider == Provider::Pi && mode != LeaderStartMode::AttachExisting {
         let parsed = crate::lifecycle::launch::pi_mcp::parse_pi_leader_args(provider_args)
             .map_err(|error| LeaderError::Start(error.to_string()))?;
@@ -303,9 +310,23 @@ fn leader_start_plan_with_ambient_authority(
             "leader",
             identity.team_id.as_str(),
         );
-        let prompt = crate::lifecycle::worker_command_context::compile_pi_leader_system_prompt();
+        let contract = crate::lifecycle::worker_command_context::compile_pi_leader_system_prompt();
+        let prompt = if let Some(stored) = configured_prompt.as_ref() {
+            // Read route once and validate conflicts before creating any Pi MCP artifacts.
+            let mut routed = vec!["pi".to_string()];
+            crate::provider::argv_route::apply(provider, &mut routed)
+                .map_err(|error| LeaderError::Start(error.to_string()))?;
+            let combined = super::prompt::compose_pi_contract(
+                &contract, &routed, &stored.text, &stored.path,
+            )?;
+            pi_routed_argv = Some(routed);
+            combined
+        } else {
+            contract
+        };
         let team_mcp_tools = ["send_message", "report_result", "get_team_status"];
-        crate::lifecycle::launch::pi_mcp::materialize_pi_plan(
+        let spawned_at = chrono::Utc::now().to_rfc3339();
+        let command = crate::lifecycle::launch::pi_mcp::materialize_pi_plan(
             crate::lifecycle::launch::pi_mcp::PiMaterializeRequest {
                 workspace,
                 team_id: identity.team_id.as_str(),
@@ -322,16 +343,32 @@ fn leader_start_plan_with_ambient_authority(
                 ),
             },
         )
-        .map_err(|error| LeaderError::Start(error.to_string()))?
-        .argv
+        .map_err(|error| LeaderError::Start(error.to_string()))?;
+        session_capture = Some(crate::provider::CaptureSessionContext {
+            agent_id: "leader".into(),
+            spawn_cwd: resolve_workspace_for_hash(workspace),
+            pane_id: None,
+            pane_pid: None,
+            spawned_at: Some(spawned_at),
+            expected_session_id: command.expected_session_id,
+            provider_projects_root: command.provider_projects_root,
+        });
+        command.argv
     } else if provider == Provider::Pi {
         Vec::new()
     } else {
         provider_command_argv(provider, provider_args)
     };
     if mode != LeaderStartMode::AttachExisting {
-        crate::provider::argv_route::apply(provider, &mut provider_argv)
-            .map_err(|error| LeaderError::Start(error.to_string()))?;
+        if let Some(routed) = pi_routed_argv {
+            provider_argv.splice(1..1, routed.into_iter().skip(1));
+        } else {
+            crate::provider::argv_route::apply(provider, &mut provider_argv)
+                .map_err(|error| LeaderError::Start(error.to_string()))?;
+            if let Some(stored) = configured_prompt.as_ref() {
+                super::prompt::inject(provider, &mut provider_argv, &stored.text, &stored.path)?;
+            }
+        }
     }
     let argv = start_argv(
         mode,
@@ -361,6 +398,10 @@ fn leader_start_plan_with_ambient_authority(
         session_name: plan_session_name,
         argv,
         provider_argv,
+        leader_prompt: configured_prompt
+            .as_ref()
+            .map(|stored| stored.metadata(provider)),
+        session_capture,
         // 0.3.28 Step 2: leader window inside the dedicated leader session is
         // named after the provider wire (e.g. `claude_code`), never the
         // literal string `leader`. Occupied names get a per-launch suffix.
@@ -1345,7 +1386,7 @@ fn ensure_managed_leader_pane(
                 &env_unset,
                 provider_label,
             )
-            .map_err(|error| LeaderError::Start(error.to_string()))
+            .map_err(|error| prompt_aware_spawn_error(plan, error))
     } else {
         let env_unset = leader_env_unset_for_provider(plan.provider);
         let provider_label = provider_command_name(plan.provider);
@@ -1359,8 +1400,35 @@ fn ensure_managed_leader_pane(
                 &env_unset,
                 provider_label,
             )
-            .map_err(|error| LeaderError::Start(error.to_string()))
+            .map_err(|error| prompt_aware_spawn_error(plan, error))
+    }
+}
+
+fn prompt_aware_spawn_error(plan: &LeaderStartPlan, error: TransportError) -> LeaderError {
+    let Some(metadata) = plan.leader_prompt.as_ref() else {
+        return LeaderError::Start(error.to_string());
+    };
+    // Transport subprocess errors contain the full tmux shell argv. Preserve
+    // real exit/I/O evidence without exposing the process-level prompt payload.
+    let mut safe = super::prompt::PromptError::new(
+        "leader_prompt_carrier_failed",
+        "Leader prompt-bearing transport spawn failed; argv and stderr withheld",
+        Some(&metadata.config_path),
+    )
+    .for_provider(plan.provider);
+    match error {
+        TransportError::Subprocess { code, .. } => safe.exit_code = code,
+        TransportError::Spawn { source, .. } | TransportError::Inject { source, .. }
+            | TransportError::Capture { source } | TransportError::Io(source) => {
+            safe.io_kind = Some(format!("{:?}", source.kind()));
+        }
+        oversized @ TransportError::CommandTooLong { .. } => {
+            safe.error = oversized.to_string();
+        }
+        _ => {}
     }
+    safe.action = "Inspect the owned launcher and transport metadata; do not repeat or change carriers to bypass the failure";
+    LeaderError::Prompt(safe)
 }
 
 struct ManagedAttachWatch<'a> {
@@ -1740,6 +1808,25 @@ fn managed_spawned_pane_in_targets(transport: &dyn Transport, spawned: &SpawnRes
         })
 }
 
+/// Keep the launcher's native identity with the canonical pane. The backing
+/// JSONL may not exist until Pi's first turn; receipt observation resolves it by
+/// exact header, never by filename/mtime or the Team Agent owner UUID.
+fn bind_plan_session(receiver: &mut serde_json::Value, plan: &LeaderStartPlan) {
+    if let Some(capture) = &plan.session_capture {
+        let native = serde_json::json!({
+            "expected_session_id": capture.expected_session_id,
+            "provider_projects_root": capture.provider_projects_root,
+            "spawn_cwd": capture.spawn_cwd,
+            "spawned_at": capture.spawned_at,
+            "pane_id": receiver.get("pane_id"),
+            "tmux_socket": receiver.get("tmux_socket"),
+            "leader_session_uuid": receiver.get("leader_session_uuid"),
+            "owner_epoch": receiver.get("owner_epoch"),
+        });
+        receiver["native_session"] = native;
+    }
+}
+
 fn persist_managed_leader_binding(
     plan: &LeaderStartPlan,
     workspace: &Path,
@@ -1855,7 +1942,7 @@ fn persist_managed_leader_binding(
     } else {
         serde_json::json!("managed_launcher")
     };
-    let receiver = serde_json::json!({
+    let mut receiver = serde_json::json!({
         "mode": "direct_tmux",
         "status": "attached",
         "provider": provider.clone(),
@@ -1870,6 +1957,15 @@ fn persist_managed_leader_binding(
         "discovery": discovery,
         "bound_panes": bound_panes,
     });
+    if keep_existing_scalar {
+        for key in ["native_session", "rollout_path"] {
+            if let Some(value) = existing_recv.as_ref().and_then(|old| old.get(key)) {
+                receiver[key] = value.clone();
+            }
+        }
+    } else {
+        bind_plan_session(&mut receiver, plan);
+    }
     let owner_uuid = if keep_existing_scalar {
         keep_field(
             existing_owner.as_ref(),
@@ -2028,6 +2124,7 @@ fn persist_exec_provider_leader_binding(
         }
         obj.insert("tmux_socket".to_string(), serde_json::json!(socket));
     }
+    bind_plan_session(&mut receiver, plan);
     let owner = serde_json::json!({
         "pane_id": pane,
         "provider": provider.clone(),
@@ -2043,10 +2140,8 @@ fn persist_exec_provider_leader_binding(
             "active_team_key".to_string(),
             serde_json::json!(identity.team_id.as_str()),
         );
-        obj.insert(
-            "session_name".to_string(),
-            serde_json::json!(target.session.as_str()),
-        );
+        // The ambient session identifies the leader receiver, not workers.
+        // Leave any existing worker session untouched, including unknown state.
         obj.insert("tmux_endpoint".to_string(), serde_json::json!(socket));
         obj.insert("tmux_socket".to_string(), serde_json::json!(socket));
         obj.insert(
@@ -2421,6 +2516,11 @@ fn run_leader_argv(
             diagnostics_path.display()
         ))
     })?;
+    // Captured transport diagnostics can echo the shell argv carrying the
+    // prompt. Do not tee those bytes before redaction. Native ExecProvider
+    // business streams and inherited TTY stdout keep their existing behavior.
+    let withhold_transport_output = plan.leader_prompt.is_some()
+        && plan.mode != LeaderStartMode::ExecProvider;
     let stdout_reader = child.stdout.take().map(|mut child_stdout| {
         std::thread::spawn(move || {
             let mut captured = Vec::new();
@@ -2432,7 +2532,9 @@ fn run_leader_argv(
                 if read == 0 {
                     break;
                 }
-                let _ = std::io::stdout().write_all(&buf[..read]);
+                if !withhold_transport_output {
+                    let _ = std::io::stdout().write_all(&buf[..read]);
+                }
                 captured.extend_from_slice(&buf[..read]);
             }
             captured
@@ -2449,7 +2551,9 @@ fn run_leader_argv(
                 if read == 0 {
                     break;
                 }
-                let _ = std::io::stderr().write_all(&buf[..read]);
+                if !withhold_transport_output {
+                    let _ = std::io::stderr().write_all(&buf[..read]);
+                }
                 captured.extend_from_slice(&buf[..read]);
             }
             captured
@@ -2487,8 +2591,8 @@ fn run_leader_argv(
                 .code()
                 .map(|code| code.to_string())
                 .unwrap_or_else(|| "signal".to_string()),
-            crate::redaction::redact_external_text(&stdout),
-            crate::redaction::redact_external_text(&stderr),
+            prompt_aware_diagnostic_text(plan, &stdout),
+            prompt_aware_diagnostic_text(plan, &stderr),
         ),
     )
     .map_err(|error| {
@@ -2497,6 +2601,11 @@ fn run_leader_argv(
             diagnostics_path.display()
         ))
     })?;
+    let stderr = if plan.leader_prompt.is_some() {
+        prompt_aware_diagnostic_text(plan, &stderr)
+    } else {
+        stderr
+    };
     Ok(LeaderProcessExit {
         status,
         stderr,
@@ -2591,6 +2700,14 @@ fn launcher_diagnostics_path(workspace: &Path) -> PathBuf {
     ))
 }
 
+fn prompt_aware_diagnostic_text(plan: &LeaderStartPlan, text: &str) -> String {
+    if plan.leader_prompt.is_some() {
+        "[withheld: Leader prompt-bearing launch]".to_string()
+    } else {
+        crate::redaction::redact_external_text(text)
+    }
+}
+
 fn write_launcher_diagnostics_header(
     path: &Path,
     plan: &LeaderStartPlan,
@@ -2599,13 +2716,22 @@ fn write_launcher_diagnostics_header(
     if let Some(parent) = path.parent() {
         std::fs::create_dir_all(parent)?;
     }
+    let metadata = plan
+        .leader_prompt
+        .as_ref()
+        .map(serde_json::to_string)
+        .transpose()
+        .map_err(|error| std::io::Error::new(std::io::ErrorKind::InvalidData, error))?
+        .map(|metadata| format!("leader_prompt={metadata}\n"))
+        .unwrap_or_default();
     std::fs::write(
         path,
         format!(
-            "startup_stage=prepare\nmode={:?}\nprovider={}\nargv={}\n",
+            "startup_stage=prepare\nmode={:?}\nprovider={}\nargv={}\n{}",
             plan.mode,
             provider_wire(plan.provider),
-            crate::redaction::redact_external_text(&argv.join(" ")),
+            prompt_aware_diagnostic_text(plan, &argv.join(" ")),
+            metadata,
         ),
     )
 }
@@ -2934,7 +3060,8 @@ mod tests {
         execute_leader_plan_after_ambient_authority, format_launcher_failure,
         handle_exec_provider_startup_prompts, is_interactive_shell_basename,
         lock_down_window_rename, managed_client_argv, managed_leader_window_from_occupied,
-        persist_managed_leader_binding, push_bounded_stderr, shlex_quote,
+        persist_exec_provider_leader_binding, persist_managed_leader_binding,
+        push_bounded_stderr, shlex_quote,
         write_window_rename_lockdown_event, ManagedClientAttachMode, VerifiedAmbientPaneAuthority,
         LEADER_STDERR_LIMIT,
     };
@@ -3345,6 +3472,8 @@ mod tests {
             session_name: None,
             argv: vec!["sh".to_string(), "-c".to_string(), command],
             provider_argv: vec!["codex".to_string()],
+            leader_prompt: None,
+            session_capture: None,
             leader_window: None,
             is_external_leader: true,
             leader_env: BTreeMap::new(),
@@ -3365,6 +3494,95 @@ mod tests {
         let _ = std::fs::remove_dir_all(&workspace);
     }
 
+    fn exec_binding_fixture(workspace: &Path) -> (LeaderStartPlan, VerifiedAmbientPaneAuthority) {
+        let identity = LeaderIdentity {
+            leader_session_uuid: LeaderSessionUuid::derive(
+                "fp", &workspace.to_string_lossy(), "tester", "current",
+            ).unwrap(),
+            leader_session_uuid_source: LeaderSessionUuidSource::Derived,
+            machine_fingerprint: "fp".into(), workspace_abspath: workspace.into(),
+            os_user: "tester".into(), team_id: TeamKey::new("current"),
+        };
+        let plan = LeaderStartPlan {
+            mode: LeaderStartMode::ExecProvider, provider: Provider::Pi,
+            workspace: workspace.into(), socket: LeaderLaunchSocket::Workspace,
+            session_name: None, argv: vec![], provider_argv: vec!["pi".into()],
+            leader_prompt: None, session_capture: None, leader_window: None,
+            is_external_leader: false, leader_env: BTreeMap::new(),
+            identity: Some(identity), detached: false,
+        };
+        let authority = VerifiedAmbientPaneAuthority {
+            pane_id: PaneId::new("%77"),
+            observed: PaneInfo {
+                pane_id: PaneId::new("%77"), session: SessionName::new("cursor-gate-leader"),
+                window_index: Some(0), window_name: Some(WindowName::new("pi")),
+                pane_index: Some(0), tty: Some("/dev/ttys077".into()),
+                current_command: Some("pi".into()), current_path: Some(workspace.into()),
+                active: true, pane_pid: None, leader_env: BTreeMap::new(),
+            },
+            endpoint: "/private/tmp/fixture-exec-leader.sock".into(),
+            tmux: "/private/tmp/fixture-exec-leader.sock,123,0".into(),
+        };
+        (plan, authority)
+    }
+
+    fn exec_binding_workspace() -> std::path::PathBuf {
+        let workspace = std::env::temp_dir().join(format!("ta-exec-bootstrap-{}-{}",
+            std::process::id(), std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()));
+        std::fs::create_dir(&workspace).unwrap();
+        workspace
+    }
+
+    #[test]
+    fn exec_provider_non_prefixed_receiver_produces_fresh_quick_start_bootstrap() {
+        let workspace = exec_binding_workspace();
+        let (plan, authority) = exec_binding_fixture(&workspace);
+        persist_exec_provider_leader_binding(&plan, &workspace, &authority, false).unwrap();
+        let state = crate::state::persist::load_runtime_state(&workspace).unwrap();
+        let before = state.clone();
+        assert!(state["session_name"].is_null());
+        assert!(state["teams"]["current"]["session_name"].is_null());
+        assert_eq!(state["teams"]["current"]["leader_receiver"]["session_name"], "cursor-gate-leader");
+        assert!(!crate::lifecycle::launch::quick_start_has_runtime_for_test(&state, "current"));
+        assert_eq!(state, before);
+        std::fs::remove_dir_all(workspace).unwrap();
+    }
+
+    #[test]
+    fn exec_provider_preserves_existing_workers_and_never_clears_runtime_markers() {
+        for status in ["running", "stopped", "unknown"] {
+            let workspace = exec_binding_workspace();
+            let (plan, authority) = exec_binding_fixture(&workspace);
+            let path = crate::state::persist::runtime_state_path(&workspace);
+            std::fs::create_dir_all(path.parent().unwrap()).unwrap();
+            std::fs::write(&path, serde_json::json!({
+                "active_team_key":"current", "session_name":"team-existing-workers",
+                "spec_path":"/fixture/spec.yml", "team_dir":"/fixture/roles",
+                "agents":{"worker":{"agent_id":"worker","provider":"pi","status":status}},
+                "tasks":[{"task_id":"existing-task"}],
+            }).to_string()).unwrap();
+            persist_exec_provider_leader_binding(&plan, &workspace, &authority, false).unwrap();
+            let state = crate::state::persist::load_runtime_state(&workspace).unwrap();
+            for row in [&state, &state["teams"]["current"]] {
+                assert_eq!(row["session_name"], "team-existing-workers");
+                assert_eq!(row["agents"]["worker"]["status"], status);
+                assert_eq!(row["spec_path"], "/fixture/spec.yml");
+                assert_eq!(row["team_dir"], "/fixture/roles");
+                assert_eq!(row["tasks"][0]["task_id"], "existing-task");
+            }
+            // Ownership writers update only the canonical team record, not the
+            // legacy root view that retains the existing worker runtime.
+            assert_eq!(
+                state["teams"]["current"]["leader_receiver"]["session_name"],
+                "cursor-gate-leader"
+            );
+            assert!(state["leader_receiver"].is_null());
+            assert!(crate::lifecycle::launch::quick_start_has_runtime_for_test(&state, "current"));
+            std::fs::remove_dir_all(workspace).unwrap();
+        }
+    }
+
     #[test]
     #[serial_test::serial(env)]
     fn default_exec_provider_persists_current_pane_binding_before_provider_exec() {
@@ -3402,6 +3620,8 @@ mod tests {
             session_name: None,
             argv: vec!["sh".to_string(), "-c".to_string(), command],
             provider_argv: vec!["fake".to_string()],
+            leader_prompt: None,
+            session_capture: None,
             leader_window: None,
             is_external_leader: false,
             leader_env: BTreeMap::new(),
@@ -3931,6 +4151,8 @@ mod tests {
             session_name: Some(SessionName::new("team-agent-leader-claude_code-demo")),
             argv: vec!["tmux".to_string(), "attach-session".to_string()],
             provider_argv: vec!["claude".to_string()],
+            leader_prompt: None,
+            session_capture: None,
             leader_window: Some(WindowName::new("claude_code")),
             is_external_leader: false,
             leader_env: BTreeMap::new(),
@@ -3939,6 +4161,74 @@ mod tests {
         }
     }
 
+    #[cfg(unix)]
+    #[test]
+    fn leader_prompt_transport_capture_hides_argv_echo_without_muting_native_exec() {
+        const TEST: &str = "leader::start::tests::leader_prompt_transport_capture_hides_argv_echo_without_muting_native_exec";
+        const KEY: &str = "TEAM_AGENT_TEST_PROMPT_CAPTURE_CASE";
+        const BODY: &str = "SENSITIVE_PROMPT_309_CAPTURE";
+        if let Ok(case) = std::env::var(KEY) {
+            let root = std::env::temp_dir().join(format!("ta-prompt-capture-{}-{case}", std::process::id()));
+            std::fs::create_dir_all(&root).unwrap();
+            let mut plan = persist_test_plan(&root);
+            plan.mode = if case == "exec_configured" { LeaderStartMode::ExecProvider } else { LeaderStartMode::NewTmuxSession };
+            if case != "transport_absent" {
+                plan.leader_prompt = Some(crate::leader::prompt::PromptMetadata {
+                    config_path: root.join("leader-prompt.txt"), carrier: "--append-system-prompt", bytes: BODY.len(),
+                });
+            }
+            // Controlled launcher echoes its received argv and fails; no native Agent/Team.
+            let argv = vec!["/bin/sh".to_string(), "-c".to_string(),
+                "printf '%s\\n' \"$1\"; printf '%s\\n' \"$1\" >&2; exit 23".to_string(), "launcher".to_string(), BODY.to_string()];
+            let outcome = super::run_leader_argv(&argv, &BTreeMap::new(), &plan, &root, None).unwrap();
+            assert_eq!(outcome.status.code(), Some(23));
+            if plan.leader_prompt.is_some() { assert!(!outcome.stderr.contains(BODY)); }
+            std::fs::remove_dir_all(root).unwrap();
+            return;
+        }
+        for case in ["transport_configured", "transport_absent", "exec_configured"] {
+            let output = std::process::Command::new(std::env::current_exe().unwrap())
+                .args(["--exact", TEST, "--nocapture", "--test-threads=1"])
+                .env(KEY, case).env_remove("TMUX").env_remove("TMUX_PANE")
+                .output().unwrap();
+            assert!(output.status.success(), "controlled child failed: {:?} {}", output.status, String::from_utf8_lossy(&output.stderr));
+            for bytes in [&output.stdout, &output.stderr] {
+                assert_eq!(String::from_utf8_lossy(bytes).contains(BODY), case != "transport_configured", "capture policy differs for {case}");
+            }
+        }
+    }
+
+    #[test]
+    fn leader_prompt_diagnostics_hide_payload_but_keep_unconfigured_baseline_and_native_cause() {
+        let root = std::env::temp_dir().join(format!("ta-prompt-diagnostics-{}", std::process::id()));
+        std::fs::create_dir_all(&root).unwrap();
+        let path = root.join("launcher.log");
+        let mut plan = persist_test_plan(&root);
+        let plain = vec!["tmux".to_string(), "attach-session".to_string()];
+        super::write_launcher_diagnostics_header(&path, &plan, &plain).unwrap();
+        assert_eq!(std::fs::read_to_string(&path).unwrap(),
+            "startup_stage=prepare\nmode=ManagedTmuxClient\nprovider=claude_code\nargv=tmux attach-session\n");
+        const BODY: &str = "LEADER_ONLY_SENSITIVE_309";
+        plan.leader_prompt = Some(crate::leader::prompt::PromptMetadata {
+            config_path: root.join("leader-prompt.txt"), carrier: "--append-system-prompt", bytes: BODY.len(),
+        });
+        let shell = vec!["tmux".to_string(), "new-session".to_string(),
+            format!("claude --append-system-prompt '{BODY}'")];
+        super::write_launcher_diagnostics_header(&path, &plan, &shell).unwrap();
+        let header = std::fs::read_to_string(&path).unwrap();
+        assert!(!header.contains(BODY));
+        assert!(header.contains("leader_prompt={") && header.contains("--append-system-prompt"));
+        assert!(!super::prompt_aware_diagnostic_text(&plan, BODY).contains(BODY));
+        let error = super::prompt_aware_spawn_error(&plan, TransportError::Subprocess {
+            argv: shell, code: Some(7), stderr: BODY.to_string(),
+        });
+        let crate::leader::LeaderError::Prompt(error) = error else { panic!("typed carrier failure required") };
+        assert_eq!(error.reason, "leader_prompt_carrier_failed");
+        assert_eq!(error.exit_code, Some(7));
+        assert!(!error.report().to_string().contains(BODY));
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
     #[test]
     fn multi_leader_window_keeps_base_when_free() {
         let window =
@@ -4020,6 +4310,48 @@ mod tests {
         let _ = std::fs::remove_dir_all(&workspace);
     }
 
+    #[test]
+    fn pi_managed_leader_persists_native_identity_with_the_canonical_pane() {
+        let workspace = std::env::temp_dir().join(format!(
+            "ta-pi-leader-native-binding-{}", std::process::id()
+        ));
+        std::fs::create_dir_all(workspace.join(".team/runtime")).unwrap();
+        let mut plan = persist_test_plan(&workspace);
+        plan.provider = Provider::Pi;
+        plan.session_capture = Some(crate::provider::CaptureSessionContext {
+            agent_id: "leader".into(),
+            spawn_cwd: workspace.clone(),
+            pane_id: None,
+            pane_pid: None,
+            spawned_at: Some("2026-10-10T03:59:07Z".into()),
+            expected_session_id: Some(crate::provider::SessionId::new("native-first")),
+            provider_projects_root: Some(workspace.join("pi-sessions")),
+        });
+        let mut pane = SpawnResult {
+            pane_id: PaneId::new("%0"),
+            session: SessionName::new("team-agent-leader-pi-demo"),
+            window: WindowName::new("pi"),
+            child_pid: Some(1),
+        };
+        persist_managed_leader_binding(&plan, &workspace, &pane).unwrap();
+        let first = crate::state::persist::load_runtime_state(&workspace).unwrap();
+        let receiver = &first["teams"]["current"]["leader_receiver"];
+        let native = &receiver["native_session"];
+        assert_eq!(native["expected_session_id"], "native-first");
+        assert_ne!(native["expected_session_id"], receiver["leader_session_uuid"]);
+        assert_eq!(native["provider_projects_root"], serde_json::json!(workspace.join("pi-sessions")));
+        for key in ["pane_id", "tmux_socket", "leader_session_uuid", "owner_epoch"] {
+            assert_eq!(native[key], receiver[key]);
+        }
+        pane.pane_id = PaneId::new("%1");
+        plan.session_capture.as_mut().unwrap().expected_session_id =
+            Some(crate::provider::SessionId::new("native-second"));
+        persist_managed_leader_binding(&plan, &workspace, &pane).unwrap();
+        let second = crate::state::persist::load_runtime_state(&workspace).unwrap();
+        assert_eq!(second["teams"]["current"]["leader_receiver"]["native_session"], *native);
+        let _ = std::fs::remove_dir_all(workspace);
+    }
+
     #[test]
     fn multi_leader_persist_keeps_first_owner_uuid() {
         let workspace = std::env::temp_dir().join(format!(

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

@@ -1,6 +1,8 @@
 #![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
 use super::*;
 
+mod prompt_contract;
+
 // ── helpers ────────────────────────────────────────────────────────────
 /// derive 一个真 LeaderSessionUuid(骨架无公开裸构造器,仅 `derive`)。
 fn uuid(fp: &str, ws: &str, user: &str, team: &str) -> LeaderSessionUuid {