@team-agent/installer 0.5.112 → 0.5.114

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.
@@ -403,6 +444,11 @@ pub(crate) fn leader_env_for_identity(
             "1".to_string(),
         );
     }
+    // Managed providers run after `sh -lc`; restore the launcher's native
+    // executable lookup path at invocation, not just in the tmux client env.
+    if let Some(path) = std::env::var_os("PATH").and_then(|path| path.into_string().ok()) {
+        leader_env.insert("PATH".to_string(), path);
+    }
     leader_env
 }
 
@@ -1340,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);
@@ -1354,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> {
@@ -1735,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,
@@ -1850,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(),
@@ -1865,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(),
@@ -2023,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(),
@@ -2416,6 +2518,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();
@@ -2427,7 +2534,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
@@ -2444,7 +2553,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
@@ -2482,8 +2593,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| {
@@ -2492,6 +2603,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,
@@ -2586,6 +2702,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,
@@ -2594,13 +2718,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,
         ),
     )
 }
@@ -3340,6 +3473,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(),
@@ -3397,6 +3532,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(),
@@ -3926,6 +4063,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(),
@@ -3934,6 +4073,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 =
@@ -4015,6 +4222,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/identity.rs

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

package/crates/team-agent/src/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 {