@team-agent/installer 0.5.74 → 0.5.75

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

@@ -26,6 +26,41 @@ use super::{
 
 // ── leader::lease — attach / claim / takeover / autobind / readopt 统一 CAS 路径 ──
 
+#[derive(Debug, Clone)]
+pub(crate) struct AppliedLeaderGrant {
+    pub(crate) owner: Value,
+    pub(crate) receiver: Value,
+}
+
+#[derive(Debug)]
+pub(crate) struct AttachLeaderError {
+    source: LeaderError,
+    applied_grant: Option<AppliedLeaderGrant>,
+}
+
+impl AttachLeaderError {
+    fn with_applied(source: LeaderError, applied_grant: Option<AppliedLeaderGrant>) -> Self {
+        Self {
+            source,
+            applied_grant,
+        }
+    }
+
+    pub(crate) fn into_parts(self) -> (LeaderError, Option<AppliedLeaderGrant>) {
+        (self.source, self.applied_grant)
+    }
+
+    fn into_error(self) -> LeaderError {
+        self.source
+    }
+}
+
+impl From<LeaderError> for AttachLeaderError {
+    fn from(source: LeaderError) -> Self {
+        Self::with_applied(source, None)
+    }
+}
+
 /// `attach_leader`(card §42;`__init__.py:19`)。手动 CLI attach;持 `LEADER_OWNERSHIP_LOCK`
 /// 整段临界区做 state 变更 + 事件 + 双写 + requeue exhausted watchers。
 pub fn attach_leader(
@@ -454,63 +489,140 @@ pub(crate) fn attach_leader_to_state(
     source: LeaseSource,
     require_current: bool,
 ) -> Result<(LeaderReceiver, Value), LeaderError> {
-    let _ = (source, require_current);
+    attach_leader_to_state_with_target_and_controls(
+        workspace,
+        state,
+        pane,
+        provider,
+        event_log,
+        source,
+        require_current,
+        None,
+        None,
+        None,
+        None,
+    )
+    .map_err(AttachLeaderError::into_error)
+}
+
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn attach_leader_to_state_with_target(
+    workspace: &Path,
+    state: &mut Value,
+    pane: Option<&PaneId>,
+    provider: Provider,
+    event_log: &crate::event_log::EventLog,
+    source: LeaseSource,
+    require_current: bool,
+    caller_target: Option<&PaneInfo>,
+) -> Result<(LeaderReceiver, Value), LeaderError> {
+    attach_leader_to_state_with_target_and_controls(
+        workspace,
+        state,
+        pane,
+        provider,
+        event_log,
+        source,
+        require_current,
+        caller_target,
+        None,
+        None,
+        None,
+    )
+    .map_err(AttachLeaderError::into_error)
+}
+
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn attach_leader_to_state_with_target_and_controls(
+    workspace: &Path,
+    state: &mut Value,
+    pane: Option<&PaneId>,
+    provider: Provider,
+    event_log: &crate::event_log::EventLog,
+    source: LeaseSource,
+    require_current: bool,
+    caller_target: Option<&PaneInfo>,
+    expected_owner: Option<&Value>,
+    expected_receiver: Option<&Value>,
+    nonce_writer: Option<&dyn Fn(&str, &PaneId, &str) -> Result<String, LeaderError>>,
+) -> Result<(LeaderReceiver, Value), AttachLeaderError> {
+    if expected_owner.is_some() != expected_receiver.is_some() {
+        return Err(AttachLeaderError::from(LeaderError::Validation(
+            "fresh caller CAS requires both expected owner and receiver".to_string(),
+        )));
+    }
     let pane_id = pane
         .cloned()
         .ok_or_else(|| LeaderError::Validation("tmux pane not found".to_string()))?;
     let non_empty_pane_id = NonEmptyPaneId::try_from_pane(&pane_id)?;
     let identity = leader_identity_context(workspace, None, Some(state))?;
     let epoch = current_owner_epoch(state);
-    let receiver = make_receiver(
+    let has_owner = state.get("team_owner").is_some();
+    let binding_epoch = if has_owner {
+        epoch
+    } else {
+        OwnerEpoch(epoch.0.saturating_add(1))
+    };
+    let mut receiver = make_receiver(
         provider,
         &non_empty_pane_id,
         &identity.leader_session_uuid,
-        epoch,
+        binding_epoch,
         Discovery::EnvPane,
         None,
     );
-    if state.get("team_owner").is_some() {
+    authorize_fresh_caller_receiver(
+        workspace,
+        &mut receiver,
+        &non_empty_pane_id,
+        source,
+        require_current,
+        caller_target,
+        nonce_writer,
+    )?;
+    let receiver_value = serde_json::to_value(&receiver).map_err(LeaderError::from)?;
+    if has_owner {
         write_receiver_to_state(state, &receiver)?;
     } else {
-        let next_epoch = OwnerEpoch(epoch.0.saturating_add(1));
-        let receiver = make_receiver(
-            provider,
-            &non_empty_pane_id,
-            &identity.leader_session_uuid,
-            next_epoch,
-            Discovery::EnvPane,
-            None,
-        );
-        let owner = make_owner(provider, &non_empty_pane_id, &identity, next_epoch);
+        let owner = make_owner(provider, &non_empty_pane_id, &identity, binding_epoch);
         write_binding_to_state(state, &receiver, &owner)?;
-        write_lease_dual_state(workspace, state)?;
-        event_log.write(
-            super::LeaderEvent::ReceiverAttached.name(),
-            json!({"pane_id": pane_id.as_str(), "owner_epoch": next_epoch.0}),
-        )?;
-        let team_id = TeamKey::new(crate::state::projection::team_state_key(state));
-        crate::messaging::watchers::recover_watchers_for_incident(
+    }
+    if let (Some(expected_owner), Some(expected_receiver)) = (expected_owner, expected_receiver) {
+        write_lease_dual_state_with_expected(
             workspace,
-            event_log,
-            &team_id,
-            &pane_id,
-            LeaderIncident::LeaderAttached,
+            state,
+            expected_owner,
+            expected_receiver,
         )?;
-        return Ok((receiver, json!({"ok": true})));
+    } else {
+        write_lease_dual_state(workspace, state)?;
     }
-    write_lease_dual_state(workspace, state)?;
-    event_log.write(
+    let applied_grant = state
+        .get("team_owner")
+        .cloned()
+        .map(|owner| AppliedLeaderGrant {
+            owner,
+            receiver: receiver_value,
+        });
+    if let Err(error) = event_log.write(
         super::LeaderEvent::ReceiverAttached.name(),
-        json!({"pane_id": pane_id.as_str(), "owner_epoch": epoch.0}),
-    )?;
+        json!({"pane_id": pane_id.as_str(), "owner_epoch": binding_epoch.0}),
+    ) {
+        return Err(AttachLeaderError::with_applied(
+            error.into(),
+            applied_grant.clone(),
+        ));
+    }
     let team_id = TeamKey::new(crate::state::projection::team_state_key(state));
-    crate::messaging::watchers::recover_watchers_for_incident(
+    if let Err(error) = crate::messaging::watchers::recover_watchers_for_incident(
         workspace,
         event_log,
         &team_id,
         &pane_id,
         LeaderIncident::LeaderAttached,
-    )?;
+    ) {
+        return Err(AttachLeaderError::with_applied(error.into(), applied_grant));
+    }
     Ok((receiver, json!({"ok": true})))
 }
 
@@ -1870,6 +1982,72 @@ fn emit_lease_refusal(
     Ok(())
 }
 
+fn authorize_fresh_caller_receiver(
+    workspace: &Path,
+    receiver: &mut LeaderReceiver,
+    pane: &NonEmptyPaneId,
+    source: LeaseSource,
+    require_current: bool,
+    caller_target: Option<&PaneInfo>,
+    nonce_writer: Option<&dyn Fn(&str, &PaneId, &str) -> Result<String, LeaderError>>,
+) -> Result<(), LeaderError> {
+    if !matches!(source, LeaseSource::QuickStart) || !require_current {
+        return Ok(());
+    }
+    let Some(target) = caller_target else {
+        return Ok(());
+    };
+    if target.pane_id.as_str() != pane.as_pane_id().as_str() || !target.active {
+        return Err(LeaderError::Validation(
+            "fresh caller pane observation does not match the bound pane".to_string(),
+        ));
+    }
+    let Some(current_path) = target.current_path.as_deref() else {
+        return Ok(());
+    };
+    if crate::messaging::leader_channel::path_is_in_workspace(current_path, workspace) {
+        return Ok(());
+    }
+    let Some(endpoint) = receiver
+        .tmux_socket
+        .as_deref()
+        .filter(|endpoint| !endpoint.is_empty())
+    else {
+        return Err(LeaderError::Validation(
+            "fresh cross-workspace caller requires a tmux endpoint".to_string(),
+        ));
+    };
+    if !Path::new(endpoint).is_absolute() {
+        return Err(LeaderError::Validation(
+            "fresh cross-workspace caller requires an absolute tmux endpoint".to_string(),
+        ));
+    }
+    let pane_id = pane.as_pane_id();
+    let live_nonce = if let Some(live_nonce) = target
+        .leader_env
+        .get(crate::tmux_backend::PANE_BINDING_NONCE_METADATA_KEY)
+        .filter(|nonce| !nonce.is_empty())
+        .cloned()
+    {
+        live_nonce
+    } else {
+        let nonce = pane_binding_nonce_for_claim(workspace, endpoint, pane_id, None);
+        if let Some(writer) = nonce_writer {
+            writer(endpoint, pane_id, &nonce)?
+        } else {
+            tmux_backend_for_endpoint(endpoint)
+                .set_pane_binding_nonce_if_unset(pane_id, &nonce)
+                .map_err(|error| LeaderError::Tmux(error.to_string()))?
+        }
+    };
+    receiver.scope_authority = Some(
+        crate::messaging::leader_channel::FRESH_CALLER_SCOPE_AUTHORITY.to_string(),
+    );
+    receiver.authorized_team_workspace = Some(canonical_workspace(workspace));
+    receiver.binding_nonce = Some(live_nonce);
+    Ok(())
+}
+
 fn make_receiver(
     provider: Provider,
     pane: &NonEmptyPaneId,
@@ -2237,6 +2415,24 @@ fn state_owner(state: &Value) -> Option<TeamOwner> {
 /// now persists ONLY the canonical root state; retaining the public
 /// name for 0.5.x call-site stability. The B0 legacy snapshot is
 /// diagnostic-only via `lifecycle::save_team_runtime_snapshot`.
+pub(crate) fn write_lease_dual_state_with_expected(
+    workspace: &Path,
+    state: &Value,
+    expected_owner: &Value,
+    expected_receiver: &Value,
+) -> Result<(), LeaderError> {
+    let team_key = canonical_owner_write_key(state);
+    crate::state::repository::StateRepository::new(workspace).save(
+        crate::state::repository::StateWriteIntent::ClaimLeaderFreshCaller {
+            team_key: team_key.as_str(),
+            expected_owner,
+            expected_receiver,
+        },
+        state,
+    )?;
+    Ok(())
+}
+
 pub fn write_lease_dual_state(workspace: &Path, state: &Value) -> Result<(), LeaderError> {
     // 0.5.42 S1b (s1b-writer-cluster-locate.md §4.4): terminal root
     // save routes through `StateRepository` with the `ClaimLeader`

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

@@ -20,7 +20,9 @@
 
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
 
+use std::fmt;
 use std::path::{Path, PathBuf};
+use std::time::{Duration, Instant};
 
 use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
@@ -100,10 +102,45 @@ pub const AMBIGUOUS_NAMES_FIELD: &str = "ambiguous_names";
 /// a fully-qualified form.
 pub const REASON_AMBIGUOUS: &str = "name_ambiguous";
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum RegistryRollback {
+    Restored,
+    Superseded,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum RegistryRollbackError {
+    InvalidReceipt,
+    LockUnavailable,
+    ReadFailed,
+    RestoreFailed,
+    DeleteFailed,
+}
+
+impl fmt::Display for RegistryRollbackError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let reason = match self {
+            Self::InvalidReceipt => "invalid receipt",
+            Self::LockUnavailable => "registry lock unavailable",
+            Self::ReadFailed => "registry receipt read failed",
+            Self::RestoreFailed => "registry restore failed",
+            Self::DeleteFailed => "registry delete failed",
+        };
+        f.write_str(reason)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RegistryWriteReceipt {
+    pub path: PathBuf,
+    pub bytes: Vec<u8>,
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct RegistryWriteOutcome {
     pub status: &'static str,
     pub path: Option<PathBuf>,
+    pub receipt: Option<RegistryWriteReceipt>,
     pub team_key: String,
     pub workspace_hash: String,
     pub source: String,
@@ -242,7 +279,8 @@ pub fn register_binding_from_state_best_effort(
         chrono::Utc::now().to_rfc3339(),
     );
     let event_log = crate::event_log::EventLog::new(workspace);
-    let write_result = write_entry_best_effort(&entry);
+    let write_receipt = write_entry_best_effort_with_receipt(&entry);
+    let write_result = write_receipt.as_ref().map(|receipt| receipt.path.clone());
     let status = if let Some(path) = &write_result {
         let _ = event_log.write(
             EVENT_REGISTERED,
@@ -268,6 +306,7 @@ pub fn register_binding_from_state_best_effort(
     Some(RegistryWriteOutcome {
         status,
         path: write_result,
+        receipt: write_receipt,
         team_key,
         workspace_hash: entry.workspace_hash,
         source: source.to_string(),
@@ -281,13 +320,19 @@ fn entry_filename(entry: &LeaderRegistryEntry) -> String {
 
 /// Registry write is best-effort. Writes to `.<file>.tmp-<pid>-<counter>`
 /// first, then atomically renames to `<workspace_hash>__<team_key>.json`.
-/// Returns the final path when the write succeeded, `None` otherwise —
-/// the binding command must never fail on registry errors.
+/// Every writer uses the registry lock so conditional rollback can compare
+/// and restore without racing a concurrent publish.
 pub fn write_entry_best_effort(entry: &LeaderRegistryEntry) -> Option<PathBuf> {
-    let dir = registry_dir()?;
-    if let Err(_error) = std::fs::create_dir_all(&dir) {
-        return None;
-    }
+    write_entry_best_effort_with_receipt(entry).map(|receipt| receipt.path)
+}
+
+fn write_entry_best_effort_with_receipt(
+    entry: &LeaderRegistryEntry,
+) -> Option<RegistryWriteReceipt> {
+    with_registry_lock(|dir| write_entry_locked(dir, entry)).flatten()
+}
+
+fn write_entry_locked(dir: &Path, entry: &LeaderRegistryEntry) -> Option<RegistryWriteReceipt> {
     let final_path = dir.join(entry_filename(entry));
     let tmp_name = format!(
         ".{}.tmp-{}-{}",
@@ -296,8 +341,8 @@ pub fn write_entry_best_effort(entry: &LeaderRegistryEntry) -> Option<PathBuf> {
         rand_suffix()
     );
     let tmp_path = dir.join(tmp_name);
-    let serialized = serde_json::to_string_pretty(entry).ok()?;
-    if std::fs::write(&tmp_path, serialized).is_err() {
+    let serialized = serde_json::to_vec_pretty(entry).ok()?;
+    if std::fs::write(&tmp_path, &serialized).is_err() {
         let _ = std::fs::remove_file(&tmp_path);
         return None;
     }
@@ -305,7 +350,118 @@ pub fn write_entry_best_effort(entry: &LeaderRegistryEntry) -> Option<PathBuf> {
         let _ = std::fs::remove_file(&tmp_path);
         return None;
     }
-    Some(final_path)
+    Some(RegistryWriteReceipt {
+        path: final_path,
+        bytes: serialized,
+    })
+}
+
+/// Restore one registry path only when it still contains this writer's exact
+/// receipt. The comparison and restore/delete are held under the same lock as
+/// ordinary registry writers, so a winner cannot slip in between them.
+pub fn restore_entry_if_current_matches(
+    receipt: &RegistryWriteReceipt,
+    previous: Option<&[u8]>,
+) -> Result<RegistryRollback, RegistryRollbackError> {
+    with_registry_lock_result(|dir| {
+        if receipt.path.parent() != Some(dir) {
+            return Err(RegistryRollbackError::InvalidReceipt);
+        }
+        let current = std::fs::read(&receipt.path)
+            .map_err(|_| RegistryRollbackError::ReadFailed)?;
+        if current != receipt.bytes {
+            return Ok(RegistryRollback::Superseded);
+        }
+        match previous {
+            Some(bytes) if replace_entry_bytes_locked(&receipt.path, bytes) => {
+                Ok(RegistryRollback::Restored)
+            }
+            Some(_) => Err(RegistryRollbackError::RestoreFailed),
+            None if std::fs::remove_file(&receipt.path).is_ok() => {
+                Ok(RegistryRollback::Restored)
+            }
+            None => Err(RegistryRollbackError::DeleteFailed),
+        }
+    })
+}
+
+fn remove_entry_if_matches(path: &Path, expected: &LeaderRegistryEntry) -> bool {
+    with_registry_lock(|_| {
+        let Ok(bytes) = std::fs::read(path) else {
+            return false;
+        };
+        let Ok(current) = serde_json::from_slice::<LeaderRegistryEntry>(&bytes) else {
+            return false;
+        };
+        current == *expected && std::fs::remove_file(path).is_ok()
+    })
+    .unwrap_or(false)
+}
+
+fn replace_entry_bytes_locked(path: &Path, bytes: &[u8]) -> bool {
+    let tmp = path.with_extension(format!(
+        "rollback-{}-{}",
+        std::process::id(),
+        rand_suffix()
+    ));
+    if std::fs::write(&tmp, bytes).is_err() {
+        let _ = std::fs::remove_file(&tmp);
+        return false;
+    }
+    if std::fs::rename(&tmp, path).is_err() {
+        let _ = std::fs::remove_file(&tmp);
+        return false;
+    }
+    true
+}
+
+struct RegistryLock {
+    file: std::fs::File,
+}
+
+impl RegistryLock {
+    fn acquire(dir: &Path) -> Option<Self> {
+        let path = dir.join(".registry.lock");
+        let file = std::fs::OpenOptions::new()
+            .create(true)
+            .read(true)
+            .write(true)
+            .truncate(false)
+            .open(path)
+            .ok()?;
+        let started = Instant::now();
+        loop {
+            match crate::platform::file_lock::try_lock_once_nonblocking(&file) {
+                Ok(true) => return Some(Self { file }),
+                Ok(false) if started.elapsed() < Duration::from_secs(2) => {
+                    std::thread::sleep(Duration::from_millis(10));
+                }
+                Ok(false) | Err(_) => return None,
+            }
+        }
+    }
+}
+
+impl Drop for RegistryLock {
+    fn drop(&mut self) {
+        let _ = crate::platform::file_lock::unlock(&self.file);
+    }
+}
+
+fn with_registry_lock<T>(f: impl FnOnce(&Path) -> T) -> Option<T> {
+    let dir = registry_dir()?;
+    std::fs::create_dir_all(&dir).ok()?;
+    let _lock = RegistryLock::acquire(&dir)?;
+    Some(f(&dir))
+}
+
+fn with_registry_lock_result<T>(
+    f: impl FnOnce(&Path) -> Result<T, RegistryRollbackError>,
+) -> Result<T, RegistryRollbackError> {
+    let dir = registry_dir().ok_or(RegistryRollbackError::LockUnavailable)?;
+    std::fs::create_dir_all(&dir).map_err(|_| RegistryRollbackError::LockUnavailable)?;
+    let _lock = RegistryLock::acquire(&dir).ok_or(RegistryRollbackError::LockUnavailable)?;
+    f(&dir)
 }
 
 fn rand_suffix() -> String {
@@ -324,14 +480,16 @@ fn rand_suffix() -> String {
 /// success — the invariant is "no registry entry after unbind", not
 /// "must have found something to delete".
 pub fn unregister_entry(workspace: &Path, team_key: &str) -> Option<PathBuf> {
-    let dir = registry_dir()?;
-    let hash = workspace_hash(workspace);
-    let path = dir.join(format!("{hash}__{team_key}.json"));
-    if path.exists() {
-        std::fs::remove_file(&path).ok()?;
-        return Some(path);
-    }
-    None
+    with_registry_lock(|dir| {
+        let hash = workspace_hash(workspace);
+        let path = dir.join(format!("{hash}__{team_key}.json"));
+        if path.exists() {
+            std::fs::remove_file(&path).ok()?;
+            return Some(path);
+        }
+        None
+    })
+    .flatten()
 }
 
 /// Read and deserialize every `*.json` file under the registry directory.
@@ -470,7 +628,7 @@ pub fn list_validated_with_gc() -> Vec<(LeaderRegistryEntry, &'static str, Optio
                     || r == "team_not_alive"
             })
         {
-            let _ = std::fs::remove_file(&path);
+            let _ = remove_entry_if_matches(&path, &entry);
             continue;
         }
         out.push((entry, status, reason));

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

@@ -602,7 +602,18 @@ pub(crate) fn run_pi_catalog(
         .stdout(Stdio::piped())
         .stderr(Stdio::null())
         .spawn()
-        .map_err(|_| "Pi executable is unavailable on PATH".to_string())?;
+        .map_err(|error| {
+            #[cfg(test)]
+            {
+                eprintln!(
+                    "run_pi_catalog spawn failed kind={:?} raw_os_error={:?}",
+                    error.kind(),
+                    error.raw_os_error()
+                );
+            }
+            let _ = error;
+            "Pi executable is unavailable on PATH".to_string()
+        })?;
     let stdout = child.stdout.take().ok_or_else(|| {
         let _ = child.kill();
         let _ = child.wait();