@team-agent/installer 0.5.112 → 0.5.114

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

@@ -0,0 +1,268 @@
+//! Process-isolated launch planning, not native provider inference.
+#![cfg(unix)]
+#[path = "../../../tests/support/hermetic.rs"]
+mod hermetic;
+use crate::leader::{LeaderError, LeaderStartMode};
+use crate::lifecycle::launch::pi_mcp::{materialize_pi_plan, PiMaterializeRequest, PiSessionScope};
+use crate::provider::{McpConfig, Provider};
+use hermetic::HermeticTestEnv;
+use serde_json::json;
+use std::fs;
+use std::os::unix::fs::{symlink, PermissionsExt};
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+const SENTINEL: &str = "LEADER_ONLY_309_SENTINEL_🙂";
+const CHILD: &str = "TEAM_AGENT_TEST_LEADER_PROMPT_CHILD";
+fn isolated(name: &str, body: impl FnOnce()) {
+    if std::env::var(CHILD).ok().as_deref() == Some(name) {
+        body();
+        return;
+    }
+    let output = Command::new(std::env::current_exe().unwrap())
+        .args([
+            "--exact",
+            &format!("leader::tests::prompt_contract::{name}"),
+            "--nocapture",
+            "--test-threads=1",
+        ])
+        .env(CHILD, name)
+        .output()
+        .unwrap();
+    assert!(
+        output.status.success(),
+        "isolated test failed: {:?}\n{}\n{}",
+        output.status,
+        String::from_utf8_lossy(&output.stdout),
+        String::from_utf8_lossy(&output.stderr)
+    );
+}
+fn native_bin(h: &HermeticTestEnv) -> PathBuf {
+    let bin = h.workspace("bin");
+    for name in ["claude", "codex", "grok", "agent", "copilot", "tmux"] {
+        let path = bin.join(name);
+        let source = if name == "tmux" {
+            "#!/bin/sh\nif [ \"$1\" = -V ]; then echo 'tmux 3.3'; exit 0; fi\nexit 1\n"
+        } else {
+            "#!/bin/sh\nexit 77\n"
+        };
+        fs::write(&path, source).unwrap();
+        fs::set_permissions(&path, fs::Permissions::from_mode(0o755)).unwrap();
+    }
+    let real = h.root().join("pi-real");
+    fs::write(&real, "#!/bin/sh\ncase \"$1\" in\n--version) echo '1.0.0';;\n--list-models) printf 'provider model\\nteam-agent test-model\\n';;\n*) exit 77;;\nesac\n").unwrap();
+    fs::set_permissions(&real, fs::Permissions::from_mode(0o755)).unwrap();
+    symlink(real, bin.join("pi")).unwrap();
+    bin
+}
+fn plan(
+    provider: Provider,
+    workspace: &Path,
+    args: &[String],
+    attach: bool,
+) -> Result<crate::leader::LeaderStartPlan, LeaderError> {
+    crate::leader::start::leader_start_plan_after_ambient_authority_check(
+        provider, args, workspace, attach, attach, None, true,
+    )
+}
+fn prompt_text(argv: &[String], flag: &str) -> String {
+    let index = argv.iter().position(|arg| arg == flag).unwrap();
+    argv[index + 1].clone()
+}
+fn stable_argv(plan: &crate::leader::LeaderStartPlan) -> (Vec<String>, Vec<String>) {
+    // Fresh Pi session UUIDs are intentionally regenerated; all other bytes must match.
+    let normalize = |argv: &[String]| {
+        argv.iter()
+            .map(|arg| {
+                if let Some(index) = plan
+                    .provider_argv
+                    .iter()
+                    .position(|token| token == "--session-id")
+                {
+                    arg.replace(&plan.provider_argv[index + 1], "<fresh-session-id>")
+                } else {
+                    arg.clone()
+                }
+            })
+            .collect()
+    };
+    (normalize(&plan.argv), normalize(&plan.provider_argv))
+}
+fn assert_no_payload_tree(path: &Path) {
+    for entry in fs::read_dir(path).unwrap() {
+        let path = entry.unwrap().path();
+        if path.is_dir() {
+            assert_no_payload_tree(&path);
+        } else if let Ok(bytes) = fs::read(&path) {
+            assert!(
+                !String::from_utf8_lossy(&bytes).contains(SENTINEL),
+                "payload persisted outside global file: {}",
+                path.display()
+            );
+        }
+    }
+}
+#[test]
+fn leader_prompt_plans_preserve_absent_baseline_append_only_leaders_and_never_materialize_into_workers(
+) {
+    isolated("leader_prompt_plans_preserve_absent_baseline_append_only_leaders_and_never_materialize_into_workers", || {
+        let h = HermeticTestEnv::enter("leader-prompt-plans");
+        let bin = native_bin(&h);
+        let _path = h.with_env("PATH", bin.to_str().unwrap());
+        let _routing = h.with_env("TEAM_AGENT_CLI_ARGV_ROUTING", "off");
+        let config = crate::leader::prompt::config_path().unwrap();
+        let providers = [Provider::Pi, Provider::Claude, Provider::ClaudeCode, Provider::Codex,
+            Provider::Grok, Provider::CursorAgent, Provider::Copilot];
+        for provider in providers {
+            let workspace = h.workspace(&format!("provider-{}", crate::provider::wire::provider_wire(provider)));
+            let baseline = plan(provider, &workspace, &[], false).unwrap();
+            assert!(baseline.leader_prompt.is_none());
+            fs::create_dir_all(config.parent().unwrap()).unwrap(); fs::write(&config, []).unwrap();
+            let empty = plan(provider, &workspace, &[], false).unwrap();
+            assert_eq!(stable_argv(&empty), stable_argv(&baseline), "empty configuration changed argv for {provider:?}");
+            assert_eq!(empty.leader_env, baseline.leader_env);
+            fs::write(&config, SENTINEL).unwrap();
+            if matches!(provider, Provider::CursorAgent | Provider::Copilot) {
+                let LeaderError::Prompt(error) = plan(provider, &workspace, &[], false).unwrap_err() else { panic!("typed unsupported") };
+                assert_eq!(error.reason, "leader_prompt_unsupported");
+            } else {
+                let configured = plan(provider, &workspace, &[], false).unwrap();
+                assert_eq!(configured.mode, baseline.mode);
+                assert_eq!(configured.leader_env, baseline.leader_env);
+                assert!(configured.leader_prompt.is_some());
+                assert!(configured.provider_argv.iter().any(|arg| arg.contains(SENTINEL)));
+                if provider == Provider::Pi {
+                    assert_eq!(prompt_text(&configured.provider_argv, "--append-system-prompt"),
+                        format!("{}\n\n{SENTINEL}", prompt_text(&baseline.provider_argv, "--append-system-prompt")));
+                }
+                // Only the process argv carries the global payload, never the wrapper/state/env.
+                assert_no_payload_tree(&workspace);
+            }
+            fs::remove_file(&config).unwrap();
+        }
+        fs::write(&config, SENTINEL).unwrap();
+        let workspace = h.workspace("worker");
+        let candidate = h.root().join("candidate"); fs::write(&candidate, "candidate").unwrap();
+        let mcp = McpConfig { raw: json!({"team_orchestrator": {
+            "command": candidate, "args": ["mcp-server"], "cwd": workspace,
+            "env": {"TEAM_AGENT_ID": "worker", "TEAM_AGENT_OWNER_TEAM_ID": "current"}
+        }}) };
+        for body in [SENTINEL.as_bytes(), &[0xff][..]] {
+            fs::write(&config, body).unwrap();
+            let worker = materialize_pi_plan(PiMaterializeRequest {
+                workspace: &workspace, team_id: "current", agent_id: "worker", model: None,
+                effort: None, system_prompt: "Compiled Worker contract; unchanged", team_mcp_tools: &["report_result"],
+                mcp_config: &mcp, session_scope: PiSessionScope::Isolated,
+            }).unwrap();
+            assert!(!worker.argv.iter().any(|arg| arg.contains(SENTINEL)));
+            assert!(!mcp.raw.to_string().contains(SENTINEL));
+            assert_no_payload_tree(&workspace);
+        }
+    });
+}
+#[test]
+fn leader_prompt_attach_skips_corrupt_configuration_and_all_injection_for_every_leader_entry() {
+    isolated(
+        "leader_prompt_attach_skips_corrupt_configuration_and_all_injection_for_every_leader_entry",
+        || {
+            let h = HermeticTestEnv::enter("leader-prompt-attach");
+            let bin = native_bin(&h);
+            let _path = h.with_env("PATH", bin.to_str().unwrap());
+            let _routing = h.with_env("TEAM_AGENT_CLI_ARGV_ROUTING", "off");
+            let config = crate::leader::prompt::config_path().unwrap();
+            fs::create_dir_all(config.parent().unwrap()).unwrap();
+            for provider in [
+                Provider::Pi,
+                Provider::Claude,
+                Provider::ClaudeCode,
+                Provider::Codex,
+                Provider::Grok,
+                Provider::CursorAgent,
+                Provider::Copilot,
+            ] {
+                let workspace = h.workspace(&format!("attach-{provider:?}"));
+                fs::write(&config, []).unwrap();
+                let baseline = plan(provider, &workspace, &[], true).unwrap();
+                for body in [SENTINEL.as_bytes(), &[0xff][..]] {
+                    fs::write(&config, body).unwrap();
+                    let attached = plan(provider, &workspace, &[], true).unwrap();
+                    assert_eq!(attached.mode, LeaderStartMode::AttachExisting);
+                    assert!(attached.leader_prompt.is_none());
+                    assert_eq!(attached.argv, baseline.argv);
+                    assert_eq!(attached.provider_argv, baseline.provider_argv);
+                    assert_eq!(attached.leader_env, baseline.leader_env);
+                    assert!(!workspace.join(".team").exists());
+                }
+            }
+        },
+    );
+}
+#[test]
+fn leader_prompt_routes_are_merged_or_rejected_before_pi_artifacts() {
+    isolated(
+        "leader_prompt_routes_are_merged_or_rejected_before_pi_artifacts",
+        || {
+            let h = HermeticTestEnv::enter("leader-prompt-routes");
+            let bin = native_bin(&h);
+            let _path = h.with_env("PATH", bin.to_str().unwrap());
+            let _routing = h.with_env("TEAM_AGENT_CLI_ARGV_ROUTING", "on");
+            let config = crate::leader::prompt::config_path().unwrap();
+            fs::create_dir_all(config.parent().unwrap()).unwrap();
+            fs::write(&config, SENTINEL).unwrap();
+            let route = crate::provider::argv_route::config_path().unwrap();
+            fs::write(
+                &route,
+                json!({"schema_version":1,"enabled":true,"providers":{
+                    "claude":["--append-system-prompt=from route"],
+                    "codex":["-c", "developer_instructions=\"from route\""],
+                    "grok":["--rules", "from route"]
+                }})
+                .to_string(),
+            )
+            .unwrap();
+            for provider in [Provider::Claude, Provider::Codex, Provider::Grok] {
+                let workspace = h.workspace(&format!("route-{provider:?}"));
+                let argv = plan(provider, &workspace, &[], false)
+                    .unwrap()
+                    .provider_argv;
+                assert!(argv
+                    .iter()
+                    .any(|arg| arg.contains("from route") && arg.contains(SENTINEL)));
+                let args = match provider {
+                    Provider::Codex => vec![
+                        "--config".into(),
+                        "developer_instructions=\"explicit\"".into(),
+                    ],
+                    Provider::Grok => vec!["--rules".into(), "explicit".into()],
+                    _ => vec!["--append-system-prompt".into(), "explicit".into()],
+                };
+                let LeaderError::Prompt(error) =
+                    plan(provider, &workspace, &args, false).unwrap_err()
+                else {
+                    panic!("typed duplicate refusal")
+                };
+                assert_eq!(error.reason, "leader_prompt_conflict");
+                assert!(!workspace.join(".team").exists());
+            }
+            for tokens in [
+                json!(["--append-system-prompt", "route override"]),
+                json!(["--"]),
+            ] {
+                fs::write(
+                    &route,
+                    json!({"schema_version":1,"enabled":true,"providers":{"pi":tokens}})
+                        .to_string(),
+                )
+                .unwrap();
+                let workspace = h.workspace("pi-route-refusal");
+                let LeaderError::Prompt(error) =
+                    plan(Provider::Pi, &workspace, &[], false).unwrap_err()
+                else {
+                    panic!("typed Pi route refusal")
+                };
+                assert_eq!(error.reason, "leader_prompt_conflict");
+                assert!(!workspace.join(".team").exists());
+            }
+        },
+    );
+}

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

@@ -343,6 +343,10 @@ pub struct LeaderStartPlan {
     pub argv: Vec<String>,
     /// For managed launches, the provider command argv spawned inside the leader pane.
     pub provider_argv: Vec<String>,
+    /// Payload-free launch snapshot; prompt-bearing diagnostics must withhold argv/output.
+    pub leader_prompt: Option<super::prompt::PromptMetadata>,
+    /// Native identity allocated before launch, not the Team Agent owner UUID.
+    pub session_capture: Option<crate::provider::CaptureSessionContext>,
     /// For managed launches, the window that hosts the leader provider pane.
     pub leader_window: Option<WindowName>,
     /// True for external/current-pane leader compatibility paths.
@@ -456,6 +460,8 @@ pub enum LeaderError {
     /// provider 命令未安装 / leader 启动前置失败(`leader_start_plan` raise RuntimeError)。
     #[error("leader start error: {0}")]
     Start(String),
+    #[error(transparent)]
+    Prompt(#[from] super::prompt::PromptError),
     /// tmux target scan / set-environment / send 失败(transport 层冒泡)。
     #[error("tmux error: {0}")]
     Tmux(String),

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

@@ -53,6 +53,10 @@ pub mod state;
 // step 6 (compiler) — TEAM.md + agents/*.md → 规范 team.spec dict(doc→spec 纯变换)。
 pub mod compiler;
 
+// Isolated new-provider runtime; legacy provider dispatch/state are not migrated.
+#[cfg(unix)]
+pub mod contract_runtime;
+
 // Official communication-mode catalog. Configuration compilation and every
 // future projection consumer must use this typed single source of truth.
 pub mod communication_mode;

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

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