@team-agent/installer 0.5.113 → 0.5.115

package/crates/team-agent/src/messaging/tests/leader_inject_acceptance.rs

@@ -77,6 +77,131 @@ fn tmux_leader_submit_without_provider_receipt_stays_pending_then_accepts_same_r
     assert!(case.delivery_consumed_at(&message_id).is_some());
 }
 
+fn pi_receipt_case(tag: &str) -> (Case, serde_json::Value) {
+    let mut case = Case::new_without_rollout(tag);
+    let root = case.workspace.join("pi-sessions");
+    std::fs::create_dir_all(&root).unwrap();
+    case.rollout = root.join("not-derived-from-the-session-id.jsonl");
+    let receiver = &mut case.state["leader_receiver"];
+    receiver["provider"] = serde_json::json!("pi");
+    receiver["tmux_socket"] = serde_json::json!(case.workspace.join("fixture-tmux.sock"));
+    receiver["leader_session_uuid"] = serde_json::json!("team-owner-not-native-id");
+    receiver["owner_epoch"] = serde_json::json!(1);
+    receiver["native_session"] = serde_json::json!({
+        "expected_session_id": "native-pi-session",
+        "provider_projects_root": root,
+        "spawn_cwd": case.workspace,
+        "spawned_at": "2026-10-10T03:59:07Z",
+        "pane_id": "%leader",
+        "tmux_socket": receiver["tmux_socket"],
+        "leader_session_uuid": "team-owner-not-native-id",
+        "owner_epoch": 1,
+    });
+    crate::state::persist::save_runtime_state(&case.workspace, &case.state).unwrap();
+    let header = serde_json::json!({
+        "type": "session", "version": 3, "id": "native-pi-session",
+        "cwd": case.workspace, "timestamp": "2026-10-10T03:59:08Z",
+    });
+    (case, header)
+}
+
+#[test]
+fn pi_leader_receipt_binds_exact_header_and_consumes_without_reinjection() {
+    let (case, header) = pi_receipt_case("pi-native-receipt");
+    let endpoint = case.state["leader_receiver"]["tmux_socket"].as_str().unwrap();
+    assert!(Path::new(endpoint).is_absolute());
+    let unbound = crate::messaging::resolve_live_leader_channel(
+        &case.workspace,
+        &case.state["leader_receiver"],
+        &RecordingTransport::new(""),
+    );
+    assert!(
+        matches!(
+            unbound,
+            crate::messaging::LeaderChannelResolution::Unbound(
+                crate::messaging::LeaderChannelUnbound::EndpointMismatch
+            )
+        ),
+        "{unbound:?}"
+    );
+    let transport = RecordingTransport {
+        endpoint: Some(endpoint.to_string()),
+        ..RecordingTransport::new("")
+    };
+    let message_id = case.seed_message("Pi receipt canary");
+    std::fs::write(&case.rollout, format!("{header}\n")).unwrap();
+    let first = deliver_pending_message(
+        &case.workspace,
+        &case.store,
+        &transport,
+        &message_id,
+        &case.event_log,
+        &case.state,
+    )
+    .unwrap();
+    assert!(first.ok, "{first:?}");
+    assert_eq!(
+        case.message_status(&message_id),
+        "submitted_pending_acceptance"
+    );
+    assert_eq!(transport.inject_count(), 1);
+
+    let received = serde_json::json!({
+        "type": "message", "message": {"role": "user", "content": [
+            {"type": "text", "text": format!("5535 [team-agent-token:{message_id}]")}
+        ]}
+    });
+    std::fs::write(&case.rollout, format!("{header}\n{received}\n")).unwrap();
+    let second = deliver_pending_message(
+        &case.workspace,
+        &case.store,
+        &transport,
+        &message_id,
+        &case.event_log,
+        &case.state,
+    )
+    .unwrap();
+    assert!(second.ok, "{second:?}");
+    assert_eq!(case.message_status(&message_id), "delivered");
+    assert!(case.delivery_consumed_at(&message_id).is_some());
+    assert_eq!(transport.inject_count(), 1);
+}
+
+#[test]
+fn pi_leader_receipt_refuses_missing_ambiguous_stale_and_other_owner_backing() {
+    use crate::messaging::delivery::{observe_leader_receipt, LeaderReceiptObservation::*};
+    let (mut case, header) = pi_receipt_case("pi-native-receipt-fences");
+    let old = case.workspace.join("old-leader.jsonl");
+    std::fs::write(&old, "[team-agent-token:canary]").unwrap();
+    case.state["leader"] = serde_json::json!({"rollout_path": old});
+    // An old root leader receipt cannot substitute for this native session.
+    assert_eq!(observe_leader_receipt(&case.state, "canary"), SourceUnavailable);
+    for (field, value) in [
+        ("id", serde_json::json!("another-session")),
+        ("cwd", serde_json::json!(case.workspace.join("other"))),
+        ("timestamp", serde_json::json!("2026-10-10T03:59:06Z")),
+    ] {
+        let mut wrong = header.clone();
+        wrong[field] = value;
+        std::fs::write(&case.rollout, format!("{wrong}\n[team-agent-token:canary]\n")).unwrap();
+        assert_eq!(observe_leader_receipt(&case.state, "canary"), SourceUnavailable);
+    }
+    std::fs::write(&case.rollout, format!("{header}\n")).unwrap();
+    assert_eq!(observe_leader_receipt(&case.state, "canary"), TokenAbsent);
+    let duplicate = case.rollout.with_file_name("duplicate.jsonl");
+    std::fs::write(&duplicate, format!("{header}\n[team-agent-token:canary]\n")).unwrap();
+    assert_eq!(observe_leader_receipt(&case.state, "canary"), SourceUnavailable);
+    std::fs::remove_file(duplicate).unwrap();
+    for key in ["pane_id", "tmux_socket", "leader_session_uuid", "owner_epoch"] {
+        let mut moved = case.state.clone();
+        moved["leader_receiver"][key] = serde_json::json!("changed");
+        assert_eq!(observe_leader_receipt(&moved, "canary"), SourceUnavailable);
+    }
+    case.state["leader_receiver"]["native_session"]["provider_projects_root"] =
+        serde_json::Value::Null;
+    assert_eq!(observe_leader_receipt(&case.state, "canary"), SourceUnavailable);
+}
+
 #[test]
 fn attached_leader_mailbox_is_rechecked_by_the_normal_delivery_tick() {
     let case = Case::new("mailbox");
@@ -428,6 +553,7 @@ impl Case {
 struct RecordingTransport {
     injects: Arc<AtomicUsize>,
     capture: Arc<Mutex<String>>,
+    endpoint: Option<String>,
 }
 
 impl RecordingTransport {
@@ -435,6 +561,7 @@ impl RecordingTransport {
         Self {
             injects: Arc::new(AtomicUsize::new(0)),
             capture: Arc::new(Mutex::new(capture.to_string())),
+            endpoint: None,
         }
     }
 
@@ -444,6 +571,10 @@ impl RecordingTransport {
 }
 
 impl Transport for RecordingTransport {
+    fn tmux_endpoint(&self) -> Option<String> {
+        self.endpoint.clone()
+    }
+
     fn kind(&self) -> BackendKind {
         BackendKind::Tmux
     }

package/crates/team-agent/src/model/spec.rs

@@ -16,8 +16,8 @@ use crate::model::enums::TaskStatus;
 use crate::model::errors::ModelError;
 use crate::model::ids::TaskId;
 use crate::model::task_graph::{find_dependency_cycle, TaskNode};
-use crate::model::yaml::Value as Yaml;
 use crate::model::yaml;
+use crate::model::yaml::Value as Yaml;
 use crate::provider::wire::parse_canonical_provider;
 
 const LEGACY_DISPLAY_KEY: &str = concat!("display", "_backend");
@@ -733,10 +733,13 @@ fn semantic_errors(spec: &Yaml, base_dir: &Path) -> Vec<String> {
 
     for (idx, agent) in agents.iter().enumerate() {
         let provider = agent.get("provider");
-        if !provider
-            .and_then(Yaml::as_str)
-            .is_some_and(|p| parse_canonical_provider(p).is_some())
-        {
+        if !provider.and_then(Yaml::as_str).is_some_and(|p| {
+            #[cfg(unix)]
+            if crate::contract_runtime::registry::descriptor(p).is_some() {
+                return true;
+            }
+            parse_canonical_provider(p).is_some()
+        }) {
             e.push(format!(
                 "/agents/{idx}/provider: unknown provider {}",
                 py_repr(provider)
@@ -1066,7 +1069,11 @@ mod tests {
             .iter()
             .filter(|m| m.starts_with("/agents/dangerously_skip_permissions: missing"))
             .collect();
-        assert_eq!(missing.len(), 1, "exactly one missing-field error, got: {errors:#?}");
+        assert_eq!(
+            missing.len(),
+            1,
+            "exactly one missing-field error, got: {errors:#?}"
+        );
         assert!(
             missing[0].contains("`codex_implementer`"),
             "must name the role id, got: {}",
@@ -1083,7 +1090,11 @@ mod tests {
     #[test]
     fn test_invalid_dangerously_type_rejected() {
         let text = include_str!("testdata/team.spec.yaml");
-        let bad = text.replacen("    dangerously_skip_permissions: false\n", "    dangerously_skip_permissions: \"yes\"\n", 1);
+        let bad = text.replacen(
+            "    dangerously_skip_permissions: false\n",
+            "    dangerously_skip_permissions: \"yes\"\n",
+            1,
+        );
         assert_ne!(text, bad, "fixture must contain the field");
         let spec = yaml::loads(&bad).unwrap();
         let errors = all_spec_errors(&spec);
@@ -1091,7 +1102,11 @@ mod tests {
             .iter()
             .filter(|m| m.starts_with("/agents/dangerously_skip_permissions: must be a boolean"))
             .collect();
-        assert_eq!(type_errs.len(), 1, "exactly one type error, got: {errors:#?}");
+        assert_eq!(
+            type_errs.len(),
+            1,
+            "exactly one type error, got: {errors:#?}"
+        );
         assert!(
             type_errs[0].contains("`codex_implementer`"),
             "must name the role id, got: {}",
@@ -1139,10 +1154,7 @@ mod tests {
     // 缺失 role frontmatter 值时编译为安全默认 false；此处锁定公共编译入口的结果。
     #[test]
     fn test_all_7_triggers_use_compiled_default_bypass() {
-        let team = std::env::temp_dir().join(format!(
-            "ta-spec-7trigger-{}",
-            std::process::id()
-        ));
+        let team = std::env::temp_dir().join(format!("ta-spec-7trigger-{}", std::process::id()));
         let _ = std::fs::remove_dir_all(&team);
         std::fs::create_dir_all(team.join("agents")).unwrap();
         std::fs::write(

package/crates/team-agent/src/state/persist.rs

@@ -1333,6 +1333,15 @@ fn lifecycle_placeholder(agent: &Value) -> bool {
 }
 
 fn lifecycle_peer_snapshot_is_stale(incoming: &Value, latest: &Value) -> bool {
+    // A save that omitted a not-yet-spawned peer can carry roster_stub's
+    // metadata-only row into a later save. It has neither status nor epoch;
+    // it must not conflict with the peer that has since started.
+    if incoming.get("status").is_none_or(Value::is_null)
+        && live_topology_fields(incoming).is_empty()
+        && latest.get("status").and_then(Value::as_str) == Some("running")
+    {
+        return true;
+    }
     // A concurrent clone/restart can have promoted its peer to `running`
     // while its capture tuple is still pending.  That row is still a
     // lifecycle snapshot, not a completed topology observation; preserving
@@ -2643,6 +2652,70 @@ mod tests {
         assert!(saved["agents"].get("f2").is_some());
     }
 
+    #[test]
+    fn lifecycle_authority_preserves_peer_that_started_after_roster_stub_snapshot() {
+        let ws = temp_ws();
+        write_state(
+            &ws,
+            &json!({
+                "session_name": "team-a",
+                "active_team_key": "team-a",
+                "agents": {"f1": {"provider": "claude", "status": "starting"}}
+            }),
+        );
+        // f2 loaded before f1's reservation. Persist carries the still-unspawned
+        // f1 forward as an actual roster stub, not a fabricated test shape.
+        let incoming = json!({
+            "session_name": "team-a",
+            "active_team_key": "team-a",
+            "agents": {"f2": {"provider": "claude", "status": "starting"}}
+        });
+        save_runtime_state_with_lifecycle_topology_authority(&ws, &incoming, "team-a", &["f2"])
+            .unwrap();
+        let mut stale = read_state(&ws);
+        assert!(stale["agents"]["f1"].get("status").is_none());
+        assert!(live_topology_fields(&stale["agents"]["f1"]).is_empty());
+
+        // f1 starts after f2 takes its snapshot; capture is not complete yet.
+        let mut started = stale.clone();
+        started["agents"]["f1"] = json!({
+            "provider": "claude",
+            "status": "running",
+            "pane_id": "%1",
+            "pane_pid": 101,
+            "window": "f1",
+            "spawned_at": "2026-10-11T05:55:20Z",
+            "spawn_epoch": 1,
+            "_pending_session_id": "session-f1"
+        });
+        normalize_agent_session_state(&mut started);
+        save_runtime_state_with_lifecycle_topology_authority(&ws, &started, "team-a", &["f1"])
+            .unwrap();
+        let latest = read_state(&ws);
+        stale["agents"]["f2"] = json!({
+            "provider": "claude",
+            "status": "running",
+            "pane_id": "%2",
+            "pane_pid": 102,
+            "window": "f2",
+            "spawned_at": "2026-10-11T05:55:21Z",
+            "spawn_epoch": 1,
+            "_pending_session_id": "session-f2"
+        });
+
+        // Ordinary writers still cannot overwrite the live peer from a stub.
+        assert!(matches!(
+            save_runtime_state(&ws, &stale),
+            Err(StateError::SaveConflict(_))
+        ));
+        assert_eq!(read_state(&ws), latest);
+        save_runtime_state_with_lifecycle_topology_authority(&ws, &stale, "team-a", &["f2"])
+            .unwrap();
+        let saved = read_state(&ws);
+        assert_eq!(saved["agents"]["f1"], latest["agents"]["f1"]);
+        assert_eq!(saved["agents"]["f2"], stale["agents"]["f2"]);
+    }
+
     #[test]
     fn lifecycle_authority_preserves_complete_latest_row_for_starting_peer() {
         let ws = temp_ws();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.5.113",
+  "version": "0.5.115",
   "description": "npx installer for Team Agent",
   "keywords": [
     "codex",
@@ -20,9 +20,9 @@
     "team-agent-installer": "npm/install.mjs"
   },
   "optionalDependencies": {
-    "@team-agent/cli-darwin-arm64": "0.5.113",
-    "@team-agent/cli-darwin-x64": "0.5.113",
-    "@team-agent/cli-linux-x64": "0.5.113"
+    "@team-agent/cli-darwin-arm64": "0.5.115",
+    "@team-agent/cli-darwin-x64": "0.5.115",
+    "@team-agent/cli-linux-x64": "0.5.115"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",