@team-agent/installer 0.5.68 → 0.5.69

package/crates/team-agent/src/lifecycle/tests/pi_executable_mcp_red.rs

@@ -0,0 +1,320 @@
+use std::os::unix::fs::PermissionsExt;
+use std::path::{Path, PathBuf};
+use std::sync::atomic::{AtomicU32, Ordering};
+
+use crate::lifecycle::launch::pi_mcp::{
+    parse_pi_list_models_table, validate_pi_adapter_identity, validate_pi_executable_chain,
+    validate_pi_wrapper_source, write_pi_wrapper, PiAdapterIdentity, PiExecutableChain,
+    PiExecutableFileType, PiWrapperRequest,
+};
+use crate::provider::McpConfig;
+
+#[path = "../../../tests/support/hermetic.rs"]
+mod hermetic_guard;
+use hermetic_guard::HermeticTestEnv;
+
+const PACKAGE_DIGEST: &str = "ce8b8b6154e83e9732c58bd993e7ed69390617616f4f0e7330274d5ee9e2f620";
+const INDEX_DIGEST: &str = "16d260ac25b66346baab6ecef76680324336953bafc7be8cf95b3df5c611b89e";
+const CATALOG_DIGEST: &str = "726cedb6c3f6fe80a0d7b98918d8ed5063695e01f510a48f46c4bad5daab49fe";
+static NEXT_ROOT: AtomicU32 = AtomicU32::new(0);
+const PI_WRAPPER_CHILD: &str = "TEAM_AGENT_TEST_PI_WRAPPER_CHILD";
+const PI_WRAPPER_NEGATIVE_CHILD: &str = "TEAM_AGENT_TEST_PI_WRAPPER_NEGATIVE_CHILD";
+const PI_WRAPPER_PARENT_PID: &str = "TEAM_AGENT_TEST_PI_WRAPPER_PARENT_PID";
+const PI_WRAPPER_TEST: &str = concat!(
+    "lifecycle::tests::pi_executable_mcp_red::",
+    "pi_wrapper_is_atomic_per_seat_and_embeds_exact_candidate"
+);
+const PI_WRAPPER_NEGATIVE_TEST: &str = concat!(
+    "lifecycle::tests::pi_executable_mcp_red::",
+    "pi_wrapper_import_failure_has_no_ambient_merge_fallback"
+);
+
+fn run_process_isolated(marker: &str, test_name: &str, body: impl FnOnce()) {
+    if std::env::var_os(marker).is_some() {
+        body();
+        return;
+    }
+
+    let output =
+        std::process::Command::new(std::env::current_exe().expect("current lib-test executable"))
+            .args(["--exact", test_name, "--nocapture", "--test-threads=1"])
+            .env(marker, "1")
+            .env(PI_WRAPPER_PARENT_PID, std::process::id().to_string())
+            .output()
+            .expect("run Pi wrapper send_message fixture in isolated child test process");
+    assert!(
+        output.status.success(),
+        "isolated Pi wrapper child failed: test={test_name} status={:?}\nstdout:\n{}\nstderr:\n{}",
+        output.status.code(),
+        String::from_utf8_lossy(&output.stdout),
+        String::from_utf8_lossy(&output.stderr),
+    );
+}
+
+fn assert_isolated_child() {
+    let parent_pid = std::env::var(PI_WRAPPER_PARENT_PID)
+        .expect("isolated child receives the parent test process id");
+    assert_ne!(
+        std::process::id().to_string(),
+        parent_pid,
+        "Pi wrapper send_message fixture must not run in the parent lib-test process"
+    );
+}
+
+fn temp_root(label: &str) -> PathBuf {
+    let seq = NEXT_ROOT.fetch_add(1, Ordering::Relaxed);
+    let root = std::env::temp_dir().join(format!(
+        "team-agent-pi-{label}-{}-{seq}",
+        std::process::id()
+    ));
+    std::fs::create_dir_all(&root).expect("create fixture root");
+    root
+}
+
+fn adapter_identity(root: &Path) -> PiAdapterIdentity {
+    let package_root = root.join("pi-mcp-adapter");
+    std::fs::create_dir_all(&package_root).expect("create adapter package root");
+    let package_json = package_root.join("package.json");
+    let index_ts = package_root.join("index.ts");
+    std::fs::write(&package_json, b"{}").expect("write adapter package receipt");
+    std::fs::write(&index_ts, b"export const createMcpAdapter = () => {};\n")
+        .expect("write loadable adapter entry");
+    PiAdapterIdentity {
+        package_name: "pi-mcp-adapter".to_string(),
+        version: "2.30.0".to_string(),
+        extension_entry: "./index.ts".to_string(),
+        package_json,
+        index_ts,
+        package_json_sha256: PACKAGE_DIGEST.to_string(),
+        index_ts_sha256: INDEX_DIGEST.to_string(),
+    }
+}
+
+fn mcp_config(candidate: &Path, workspace: &Path, agent_id: &str) -> McpConfig {
+    McpConfig {
+        raw: serde_json::json!({
+            "team_orchestrator": {
+                "command": candidate,
+                "args": ["mcp-server"],
+                "env": {
+                    "TEAM_AGENT_WORKSPACE": workspace,
+                    "TEAM_AGENT_ID": agent_id,
+                    "TEAM_AGENT_AGENT_ID": agent_id,
+                    "TEAM_AGENT_OWNER_TEAM_ID": "team-a",
+                    "TEAM_AGENT_AUTH_MODE": "subscription"
+                }
+            }
+        }),
+    }
+}
+
+#[test]
+fn pi_executable_chain_freezes_wrapper_real_binary_catalog_and_plugin_identity() {
+    let root = temp_root("executable-chain");
+    let chain = PiExecutableChain {
+        path_entry: PathBuf::from("/Users/fixture/.local/bin/pi"),
+        path_entry_type: PiExecutableFileType::Wrapper,
+        launch_executable: PathBuf::from("/Users/fixture/.local/bin/pi"),
+        real_binary: PathBuf::from(
+            "/opt/homebrew/lib/node_modules/@earendil-works/pi-coding-agent/dist/bundle/cli.js",
+        ),
+        pi_version: "0.84.3".to_string(),
+        catalog_sha256: CATALOG_DIGEST.to_string(),
+        adapter: adapter_identity(&root),
+    };
+    validate_pi_executable_chain(&chain).expect("the protocol-capable wrapper chain is valid");
+
+    let mut homebrew_symlink_entry = chain.clone();
+    homebrew_symlink_entry.real_binary = PathBuf::from("/opt/homebrew/bin/pi");
+    validate_pi_executable_chain(&homebrew_symlink_entry)
+        .expect("the distinct Homebrew symlink entry may resolve to the shebang cli.js target");
+
+    let mut wrong_version = chain.clone();
+    wrong_version.pi_version = "0.84.4".to_string();
+    validate_pi_executable_chain(&wrong_version)
+        .expect("an arbitrary newer Pi version with the same public protocol is valid");
+
+    let mut missing_real = chain.clone();
+    missing_real.real_binary = PathBuf::new();
+    assert!(validate_pi_executable_chain(&missing_real).is_err());
+
+    let mut wrong_catalog = chain.clone();
+    wrong_catalog.catalog_sha256 = "00".repeat(32);
+    assert!(validate_pi_executable_chain(&wrong_catalog).is_err());
+
+    let mut direct_binary = chain.clone();
+    direct_binary.path_entry = PathBuf::from("/opt/homebrew/bin/pi");
+    direct_binary.path_entry_type = PiExecutableFileType::Binary;
+    direct_binary.launch_executable = direct_binary.path_entry.clone();
+    direct_binary.real_binary = direct_binary.path_entry.clone();
+    assert!(
+        validate_pi_executable_chain(&direct_binary).is_err(),
+        "a direct Homebrew binary must not replace the verified PATH wrapper launch entry"
+    );
+
+    let mut wrong_plugin = chain;
+    wrong_plugin.adapter.version = "2.31.0".to_string();
+    wrong_plugin.adapter.package_json_sha256 = "11".repeat(32);
+    wrong_plugin.adapter.index_ts_sha256 = "22".repeat(32);
+    validate_pi_executable_chain(&wrong_plugin)
+        .expect("adapter version and content digests are diagnostic observations only");
+
+    assert!(parse_pi_list_models_table(b"provider model\nopenai-codex gpt-5.6-luna\n").is_ok());
+    assert!(parse_pi_list_models_table(b"provider model\n").is_err());
+    assert!(parse_pi_list_models_table(b"provider model\nmalformed\n").is_err());
+    std::fs::remove_dir_all(root).expect("remove executable chain fixture");
+}
+
+#[test]
+fn pi_adapter_detector_requires_exact_2_30_0_entry_and_digest() {
+    let root = temp_root("adapter-identity");
+    let exact = adapter_identity(&root);
+    validate_pi_adapter_identity(&exact).expect("protocol-capable adapter identity");
+
+    let mut wrong_name = exact.clone();
+    wrong_name.package_name = "pi-mcp-adapter-fork".to_string();
+    assert!(validate_pi_adapter_identity(&wrong_name).is_err());
+
+    let mut missing_entry = exact.clone();
+    missing_entry.extension_entry.clear();
+    missing_entry.index_ts = PathBuf::new();
+    assert!(validate_pi_adapter_identity(&missing_entry).is_err());
+
+    let mut unloadable_entry = exact.clone();
+    unloadable_entry.index_ts = root.join("pi-mcp-adapter/missing.ts");
+    assert!(validate_pi_adapter_identity(&unloadable_entry).is_err());
+
+    let mut newer_observation = exact;
+    newer_observation.version = "9.7.3".to_string();
+    newer_observation.package_json_sha256 = "11".repeat(32);
+    newer_observation.index_ts_sha256 = "22".repeat(32);
+    validate_pi_adapter_identity(&newer_observation)
+        .expect("version and digests do not define adapter protocol capability");
+    std::fs::remove_dir_all(root).expect("remove adapter identity fixture");
+}
+
+#[test]
+fn pi_wrapper_is_atomic_per_seat_and_embeds_exact_candidate() {
+    run_process_isolated(PI_WRAPPER_CHILD, PI_WRAPPER_TEST, || {
+        let hermetic = HermeticTestEnv::enter("pi-wrapper-send");
+        assert_isolated_child();
+        pi_wrapper_is_atomic_body(&hermetic);
+    });
+}
+
+fn pi_wrapper_is_atomic_body(hermetic: &HermeticTestEnv) {
+    let root = hermetic.workspace("wrapper");
+    let workspace = root.join("workspace");
+    let candidate = root.join("candidate/team-agent");
+    std::fs::create_dir_all(candidate.parent().expect("candidate parent"))
+        .expect("create candidate parent");
+    std::fs::write(&candidate, b"candidate").expect("write candidate fixture");
+    let destination = workspace.join(".team/runtime/pi/team-a/worker-a/team-mcp.ts");
+    let adapter = adapter_identity(&root);
+
+    let written = write_pi_wrapper(PiWrapperRequest {
+        destination: &destination,
+        adapter: &adapter,
+        candidate_executable: &candidate,
+        mcp_config: &mcp_config(&candidate, &workspace, "worker-a"),
+        team_id: "team-a",
+        agent_id: "worker-a",
+        workspace: &workspace,
+        include_tools: &["send_message", "report_result"],
+    })
+    .expect("atomic wrapper write");
+    assert_eq!(written, destination);
+    assert_eq!(
+        std::fs::metadata(&written)
+            .expect("wrapper metadata")
+            .permissions()
+            .mode()
+            & 0o777,
+        0o600
+    );
+
+    let source = std::fs::read_to_string(&written).expect("read wrapper");
+    assert!(source.contains(adapter.index_ts.to_string_lossy().as_ref()));
+    assert!(source.contains(candidate.to_string_lossy().as_ref()));
+    assert!(source.contains("TEAM_AGENT_ID") && source.contains("worker-a"));
+    assert!(source.contains("TEAM_AGENT_OWNER_TEAM_ID") && source.contains("team-a"));
+    assert!(source.contains("lifecycle") && source.contains("lazy"));
+    assert!(source.contains("directTools") && source.contains("false"));
+    assert!(source.contains("toolPrefix") && source.contains("server"));
+    assert!(source.contains("includeTools"));
+    assert!(source.contains("send_message") && source.contains("report_result"));
+    assert!(!source.contains("command: \"team-agent\""));
+    assert!(!source.contains("--mcp-config"));
+
+    let entries = std::fs::read_dir(destination.parent().expect("wrapper parent"))
+        .expect("list wrapper parent")
+        .map(|entry| entry.expect("entry").file_name())
+        .collect::<Vec<_>>();
+    assert_eq!(
+        entries,
+        [std::ffi::OsString::from("team-mcp.ts")],
+        "atomic write must not leave a temporary or backup sibling"
+    );
+    std::fs::remove_dir_all(root).expect("remove wrapper fixture");
+}
+
+#[test]
+fn pi_wrapper_import_failure_has_no_ambient_merge_fallback() {
+    run_process_isolated(PI_WRAPPER_NEGATIVE_CHILD, PI_WRAPPER_NEGATIVE_TEST, || {
+        let hermetic = HermeticTestEnv::enter("pi-wrapper-negative-send");
+        assert_isolated_child();
+        pi_wrapper_import_failure_body(&hermetic);
+    });
+}
+
+fn pi_wrapper_import_failure_body(hermetic: &HermeticTestEnv) {
+    let root = hermetic.workspace("wrapper-negative");
+    let workspace = root.join("workspace");
+    let candidate = root.join("candidate/team-agent");
+    std::fs::create_dir_all(candidate.parent().expect("candidate parent"))
+        .expect("create candidate parent");
+    std::fs::write(&candidate, b"candidate").expect("write candidate fixture");
+    std::fs::create_dir_all(&workspace).expect("create workspace");
+    std::fs::write(
+        workspace.join(".mcp.json"),
+        r#"{"mcpServers":{"team_orchestrator":{"command":"/tmp/ambient-evil"}}}"#,
+    )
+    .expect("write malicious ambient config");
+
+    let destination = workspace.join(".team/runtime/pi/team-a/worker-a/team-mcp.ts");
+    let adapter = adapter_identity(&root);
+    write_pi_wrapper(PiWrapperRequest {
+        destination: &destination,
+        adapter: &adapter,
+        candidate_executable: &candidate,
+        mcp_config: &mcp_config(&candidate, &workspace, "worker-a"),
+        team_id: "team-a",
+        agent_id: "worker-a",
+        workspace: &workspace,
+        include_tools: &["send_message", "report_result"],
+    })
+    .expect("isolated wrapper ignores ambient config");
+    let source = std::fs::read_to_string(&destination).expect("wrapper source");
+    assert!(!source.contains("ambient-evil"));
+    validate_pi_wrapper_source(&source, &adapter, &candidate)
+        .expect("exact isolated import and candidate");
+
+    let broken = source.replace(
+        adapter.index_ts.to_string_lossy().as_ref(),
+        "/missing/pi-mcp-adapter/index.ts",
+    );
+    let error = validate_pi_wrapper_source(&broken, &adapter, &candidate)
+        .expect_err("broken import must refuse");
+    let text = error.to_string();
+    assert!(
+        text.contains("import") || text.contains("adapter"),
+        "got {text}"
+    );
+    assert!(!broken.contains("--mcp-config"));
+
+    let missing_proxy_tools = source.replace("\"includeTools\"", "\"missingTools\"");
+    validate_pi_wrapper_source(&missing_proxy_tools, &adapter, &candidate)
+        .expect_err("wrapper without the MCP proxy tool allowlist must refuse");
+
+    std::fs::remove_dir_all(root).expect("remove wrapper fixture");
+}

package/crates/team-agent/src/lifecycle/tests/pi_lifecycle_doctor_red.rs

@@ -0,0 +1,98 @@
+use std::path::{Path, PathBuf};
+
+use crate::cli::diagnose::{pi_doctor_facts, PiBackingStatus, PiDoctorInput, PiMcpStatus};
+use crate::lifecycle::launch::pi_mcp::{pi_cleanup_plan, pi_seat_paths, PiCleanupAction};
+use crate::provider::{AuthHintStatus, ClassifySource, TurnState};
+
+fn doctor_input() -> PiDoctorInput {
+    PiDoctorInput {
+        executable_chain_verified: true,
+        pi_version: Some("0.84.3".to_string()),
+        adapter_version: Some("2.30.0".to_string()),
+        catalog_sha256: Some(
+            "726cedb6c3f6fe80a0d7b98918d8ed5063695e01f510a48f46c4bad5daab49fe".to_string(),
+        ),
+        selected_model: Some("team-agent/qwen3.8-27b".to_string()),
+        candidate_executable: Some(PathBuf::from("/candidate/team-agent")),
+        wrapper: Some(PathBuf::from(
+            "/workspace/.team/runtime/pi/team-a/worker-a/team-mcp.ts",
+        )),
+        mcp_roundtrip_at: None,
+        backing: PiBackingStatus::Pending,
+        activity: TurnState::Unknown,
+        activity_source: ClassifySource::SessionFile,
+        env_key_names: vec![
+            "TEAM_AGENT_ID".to_string(),
+            "TEAM_AGENT_OWNER_TEAM_ID".to_string(),
+        ],
+    }
+}
+
+#[test]
+fn pi_stop_retains_backing_and_never_scans_by_process_name() {
+    let paths = pi_seat_paths(Path::new("/workspace"), "team-a", "worker-a");
+    let stop = pi_cleanup_plan(PiCleanupAction::Stop, &paths);
+    assert!(
+        stop.delete_paths.is_empty(),
+        "stop must retain both the Team-owned wrapper and session backing"
+    );
+    assert!(stop.retain_paths.contains(&paths.wrapper));
+    assert!(stop.retain_paths.contains(&paths.sessions));
+    assert_eq!(
+        stop.process_name_scan, None,
+        "Pi cleanup may use exact recorded pane/child receipts, never a process-name scan"
+    );
+
+    let remove = pi_cleanup_plan(PiCleanupAction::Remove, &paths);
+    assert_eq!(remove.delete_paths, [paths.wrapper.clone()]);
+    assert!(remove.retain_paths.contains(&paths.sessions));
+    assert_eq!(remove.process_name_scan, None);
+    assert!(
+        remove
+            .delete_paths
+            .iter()
+            .all(|path| path.starts_with(&paths.runtime_root)),
+        "remove may delete only exact Team-owned seat paths"
+    );
+}
+
+#[test]
+fn pi_doctor_separates_configured_roundtrip_backing_and_activity_unknown() {
+    let facts = pi_doctor_facts(doctor_input());
+
+    assert_eq!(facts.mcp, PiMcpStatus::ConfiguredLazy);
+    assert!(
+        !facts.mcp_connected,
+        "wrapper existence is not an MCP roundtrip"
+    );
+    assert_eq!(facts.backing, PiBackingStatus::Pending);
+    assert_eq!(facts.activity, TurnState::Unknown);
+    assert_eq!(facts.activity_source, ClassifySource::SessionFile);
+    assert_eq!(facts.auth_hint, AuthHintStatus::Unknown);
+
+    let serialized = serde_json::to_string(&facts).expect("serialize doctor facts");
+    assert!(serialized.contains("configured_lazy"));
+    assert!(serialized.contains("unknown"));
+    for secret_surface in [
+        "api_key",
+        "access_token",
+        "refresh_token",
+        "cookie",
+        "authorization",
+    ] {
+        assert!(
+            !serialized.to_ascii_lowercase().contains(secret_surface),
+            "doctor must expose identity/digest/key names, never credential values"
+        );
+    }
+
+    let connected = pi_doctor_facts(PiDoctorInput {
+        mcp_roundtrip_at: Some("2026-08-29T10:02:00+00:00".to_string()),
+        backing: PiBackingStatus::Captured,
+        ..doctor_input()
+    });
+    assert_eq!(connected.mcp, PiMcpStatus::RoundtripVerified);
+    assert!(connected.mcp_connected);
+    assert_eq!(connected.backing, PiBackingStatus::Captured);
+    assert_eq!(connected.activity, TurnState::Unknown);
+}

package/crates/team-agent/src/lifecycle/tests/pi_session_delivery_red.rs

@@ -0,0 +1,216 @@
+use std::path::{Path, PathBuf};
+use std::sync::atomic::{AtomicU32, Ordering};
+use std::time::Duration;
+
+use crate::lifecycle::launch::pi_mcp::pi_seat_paths;
+use crate::messaging::delivery::{
+    paste_to_submit_floor_for_recipient, recipient_allows_explicit_queue_flush, recipient_is_busy,
+    recipient_requires_single_enter,
+};
+use crate::model::enums::{Provider, ProviderEffort};
+use crate::provider::adapters::pi::{build_pi_command_argv, PiCommandRequest, PiSessionSelector};
+use crate::provider::session_scan::{scan_session_candidates_once, CaptureSessionContext};
+use crate::provider::{get_adapter, AuthMode, ProviderError, SessionId};
+
+static NEXT_ROOT: AtomicU32 = AtomicU32::new(0);
+
+fn temp_root(label: &str) -> PathBuf {
+    let seq = NEXT_ROOT.fetch_add(1, Ordering::Relaxed);
+    let root = std::env::temp_dir().join(format!(
+        "team-agent-pi-{label}-{}-{seq}",
+        std::process::id()
+    ));
+    std::fs::create_dir_all(&root).expect("create fixture root");
+    root
+}
+
+fn write_header(path: &Path, id: &str, cwd: &Path, timestamp: &str) {
+    std::fs::create_dir_all(path.parent().expect("session parent")).expect("create session parent");
+    let header = serde_json::json!({
+        "type": "session",
+        "version": 3,
+        "id": id,
+        "cwd": cwd,
+        "timestamp": timestamp,
+    });
+    std::fs::write(
+        path,
+        format!("{header}\nsecret conversation body must not be read\n"),
+    )
+    .expect("write session fixture");
+}
+
+fn scan_context(cwd: &Path, root: &Path, id: &str, generation: &str) -> CaptureSessionContext {
+    CaptureSessionContext {
+        agent_id: "worker-a".to_string(),
+        spawn_cwd: cwd.to_path_buf(),
+        pane_id: None,
+        pane_pid: None,
+        spawned_at: Some(generation.to_string()),
+        expected_session_id: Some(SessionId::new(id)),
+        provider_projects_root: Some(root.to_path_buf()),
+    }
+}
+
+fn resume_argv(path: &Path) -> Result<Vec<String>, ProviderError> {
+    build_pi_command_argv(PiCommandRequest {
+        executable: Path::new("/verified/pi"),
+        extension: Path::new("/workspace/.team/runtime/pi/team-a/worker-a/team-mcp.ts"),
+        model: "team-agent/qwen3.8-27b",
+        effort: ProviderEffort::Medium,
+        system_prompt: "worker contract",
+        tool_categories: &["mcp_team"],
+        session_dir: Path::new("/workspace/.team/runtime/pi/team-a/worker-a/sessions"),
+        session: PiSessionSelector::Resume { path },
+        agent_id: "worker-a",
+    })
+}
+
+#[test]
+fn pi_session_capture_requires_header_id_cwd_generation_and_unique_claim() {
+    let root = temp_root("session-capture");
+    let cwd = root.join("workspace");
+    let sessions = root.join("seat/sessions");
+    std::fs::create_dir_all(&cwd).expect("create cwd");
+    let id = "652756ea-aaee-4437-a30f-40c5606826d5";
+    let generation = "2026-08-29T10:00:00Z";
+    let session_timestamp = "2026-08-29T10:00:01Z";
+    let expected_path = sessions.join("2026/08/29/session.jsonl");
+    write_header(&expected_path, id, &cwd, session_timestamp);
+
+    let context = scan_context(&cwd, &sessions, id, generation);
+    let candidates = scan_session_candidates_once(Provider::Pi, &context).expect("Pi scan");
+    assert_eq!(candidates.len(), 1);
+    assert_eq!(
+        candidates[0]
+            .captured
+            .session_id
+            .as_ref()
+            .map(SessionId::as_str),
+        Some(id)
+    );
+    assert_eq!(
+        candidates[0]
+            .captured
+            .rollout_path
+            .as_ref()
+            .map(|path| path.as_path()),
+        Some(expected_path.as_path())
+    );
+
+    for (label, header_id, header_cwd, header_timestamp) in [
+        ("wrong-id", "wrong-id", cwd.as_path(), session_timestamp),
+        ("wrong-cwd", id, root.as_path(), session_timestamp),
+        (
+            "wrong-generation",
+            id,
+            cwd.as_path(),
+            "2026-08-29T09:00:00+00:00",
+        ),
+    ] {
+        let case_root = root.join(label);
+        let case_path = case_root.join(format!("{id}.jsonl"));
+        write_header(&case_path, header_id, header_cwd, header_timestamp);
+        let case_context = scan_context(&cwd, &case_root, id, generation);
+        assert!(
+            scan_session_candidates_once(Provider::Pi, &case_context)
+                .expect("negative scan")
+                .is_empty(),
+            "filename or mtime must not override a mismatched header: {label}"
+        );
+    }
+
+    let second = sessions.join("duplicate/session.jsonl");
+    write_header(&second, id, &cwd, session_timestamp);
+    assert_eq!(
+        scan_session_candidates_once(Provider::Pi, &context)
+            .expect("ambiguous scan")
+            .len(),
+        2,
+        "multiple exact candidates must remain ambiguous for the shared allocator"
+    );
+
+    std::fs::remove_dir_all(root).expect("remove session fixture");
+}
+
+#[test]
+fn pi_restart_uses_exact_path_and_refuses_missing_backing() {
+    let root = temp_root("resume");
+    let cwd = root.join("workspace");
+    let sessions = root.join("seat/sessions");
+    std::fs::create_dir_all(&cwd).expect("create cwd");
+    let id = "cc09d133-878f-4241-920f-f7ebfefc2a9e";
+    let generation = "2026-08-29T10:00:00Z";
+    let exact = sessions.join("nested/exact.jsonl");
+    write_header(&exact, id, &cwd, "2026-08-29T10:00:01Z");
+
+    let candidates =
+        scan_session_candidates_once(Provider::Pi, &scan_context(&cwd, &sessions, id, generation))
+            .expect("resume preflight scan");
+    assert_eq!(
+        candidates.len(),
+        1,
+        "exact backing must revalidate before restart"
+    );
+
+    let argv = resume_argv(&exact).expect("resume exact path");
+    assert!(argv
+        .windows(2)
+        .any(|pair| { pair[0] == "--session" && pair[1] == exact.to_string_lossy().as_ref() }));
+    assert!(!argv.iter().any(|arg| {
+        matches!(
+            arg.as_str(),
+            "--session-id" | "-c" | "--continue" | "-r" | "--resume"
+        )
+    }));
+
+    std::fs::remove_file(&exact).expect("remove backing tooth");
+    let missing = resume_argv(&exact);
+    assert!(
+        matches!(missing, Err(ProviderError::ResumeUnavailable(_))),
+        "missing exact backing must refuse rather than create a new session: {missing:?}"
+    );
+    std::fs::remove_dir_all(root).expect("remove resume fixture");
+}
+
+#[test]
+fn pi_delivery_submits_one_enter_and_never_flushes_or_retries() {
+    let idle = serde_json::json!({
+        "agents": {
+            "worker-a": {"provider": "pi", "status": "running"}
+        }
+    });
+    assert!(recipient_requires_single_enter(&idle, "worker-a"));
+    assert!(!recipient_allows_explicit_queue_flush(&idle, "worker-a"));
+    assert_eq!(
+        paste_to_submit_floor_for_recipient(&idle, "worker-a"),
+        Duration::ZERO
+    );
+    assert!(!recipient_is_busy(&idle, "worker-a"));
+
+    let busy = serde_json::json!({
+        "agents": {
+            "worker-a": {"provider": "pi", "status": "busy"}
+        }
+    });
+    assert!(
+        recipient_is_busy(&busy, "worker-a"),
+        "known busy must take the existing send.deferred_busy path before paste"
+    );
+    assert!(recipient_requires_single_enter(&busy, "worker-a"));
+    assert!(!recipient_allows_explicit_queue_flush(&busy, "worker-a"));
+}
+
+#[test]
+fn pi_clone_is_fresh_and_fork_is_not_clone() {
+    let workspace = Path::new("/workspace");
+    let source_paths = pi_seat_paths(workspace, "team-a", "source");
+    let clone_paths = pi_seat_paths(workspace, "team-a", "clone");
+    assert_ne!(source_paths.runtime_root, clone_paths.runtime_root);
+    assert_ne!(source_paths.wrapper, clone_paths.wrapper);
+    assert_ne!(source_paths.sessions, clone_paths.sessions);
+
+    let source_session = SessionId::new("652756ea-aaee-4437-a30f-40c5606826d5");
+    let fork = get_adapter(Provider::Pi).fork(Some(&source_session), AuthMode::Subscription, None);
+    assert!(matches!(fork, Err(ProviderError::CapabilityUnsupported(_))));
+}

package/crates/team-agent/src/lifecycle/tests/restart_rebind_hotfix_252_red.rs

@@ -1068,6 +1068,7 @@ fn provider_name(provider: Provider) -> &'static str {
         Provider::GeminiCli => "gemini",
         Provider::Grok => "grok",
         Provider::CursorAgent => "cursor_agent",
+        Provider::Pi => "pi",
         Provider::Fake => "fake",
     }
 }

package/crates/team-agent/src/lifecycle/tests.rs

@@ -79,6 +79,13 @@ mod main_preserved;
 mod mcp_tool_name_format_red;
 mod phase_b_contracts;
 mod phase_golden;
+mod pi_catalog_red;
+mod pi_command_red;
+mod pi_compiler_red;
+mod pi_dual_entry_red;
+mod pi_executable_mcp_red;
+mod pi_lifecycle_doctor_red;
+mod pi_session_delivery_red;
 mod quick_start_worker_readiness_red;
 mod realmachine_clusters_1_6_red;
 mod realmachine_residual_g1_g4_red;