@team-agent/installer 0.5.117 → 0.5.119

package/Cargo.lock

@@ -727,7 +727,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.117"
+version = "0.5.119"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -11,7 +11,7 @@ exclude = ["crates/team-agent-contract"]
 
 [workspace.package]
 edition = "2021"
-version = "0.5.117"
+version = "0.5.119"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

package/crates/team-agent/src/cli/mod.rs

@@ -424,6 +424,26 @@ pub mod lifecycle_port {
         });
         if let Some(object) = value.as_object_mut() {
             object.extend(facts);
+            // Only a plain Pi entry can be retried verbatim with this command.
+            // Never drop explicit attach/external intent or provider arguments,
+            // clear the caller's environment, or adopt the unverified pane.
+            if cfg!(unix)
+                && provider == Provider::Pi
+                && attach == &LeaderLauncherArgs::default()
+            {
+                let command = "env -u TMUX -u TMUX_PANE team-agent pi";
+                object.insert("recovery_command".to_string(), json!(command));
+                object.insert(
+                    ACTION_FIELD.to_string(),
+                    json!(format!(
+                        "The inherited TMUX/TMUX_PANE could not be authorized for \
+                         requested_workspace; this is not an empty-directory error. \
+                         To explicitly retry from requested_workspace, run `{command}`. \
+                         This removes the inherited variables only for the new process \
+                         and does not detach or modify your current tmux pane. {action}"
+                    )),
+                );
+            }
         }
         value
     }

package/crates/team-agent/src/db/message_store.rs

@@ -379,9 +379,10 @@ impl MessageStore {
         status: &str,
         error: Option<&str>,
     ) -> Result<(), MessageStoreError> {
-        let conn = crate::db::schema::open_db(&self.path)?;
+        let mut conn = crate::db::schema::open_db(&self.path)?;
+        let tx = conn.transaction()?;
         let now = now_ts();
-        let changed = conn.execute(
+        let changed = tx.execute(
             "update messages
              set status = case
                  when status = 'acknowledged'
@@ -407,7 +408,7 @@ impl MessageStore {
             params![message_id, status, now, error],
         )?;
         if changed == 0 {
-            let prior: Option<String> = conn
+            let prior: Option<String> = tx
                 .query_row(
                     "select status from messages where message_id = ?1",
                     params![message_id],
@@ -449,6 +450,12 @@ impl MessageStore {
             )?;
             return Ok(());
         }
+        if status == "submitted_unverified" {
+            // Uncertainty and its independent safety net are one durable transition.
+            // Registration never depends on provider, parser, binding or paste proof.
+            crate::messaging::enter_rescue::schedule_in_tx(&tx, message_id, chrono::Utc::now())?;
+        }
+        tx.commit()?;
         Ok(())
     }
 

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

@@ -48,9 +48,6 @@ enum ManagedClientAttachMode {
     SwitchClient,
 }
 
-const DIFFERENT_TMUX_SERVER_PREFIX: &str =
-    "managed launcher refuses a different ambient tmux server";
-
 impl PreparedLeaderStart {
     pub(crate) fn plan(&self) -> &LeaderStartPlan {
         &self.plan
@@ -141,8 +138,6 @@ pub(crate) fn prepare_leader_start_with_nested_attach(
     let (ambient_authority, managed_client_attach_mode, managed_exec_provider) =
         if explicit_external_path || state_external_path {
             (ambient_pane_authority_preflight(workspace)?, None, false)
-        } else if workspace_state_is_managed_provider_reentry(workspace) {
-            (ambient_pane_authority_preflight(workspace)?, None, true)
         } else {
             managed_launcher_ambient_route(
                 provider,
@@ -159,7 +154,7 @@ pub(crate) fn prepare_leader_start_with_nested_attach(
         confirm_attach,
         attach_session,
         external_leader,
-        std::env::var_os("TMUX").is_some(),
+        ambient_authority.is_some(),
         managed_client_attach_mode,
         managed_exec_provider,
         allow_nested_attach,
@@ -613,64 +608,49 @@ fn managed_launcher_ambient_route(
     ),
     PrepareLeaderStartError,
 > {
-    let Some(tmux) = std::env::var_os("TMUX") else {
-        return Ok((
-            None,
-            Some(ManagedClientAttachMode::AttachSession),
-            false,
-        ));
+    let isolated = || (None, Some(ManagedClientAttachMode::AttachSession), false);
+    let authority = match ambient_pane_authority_preflight(workspace) {
+        Ok(Some(authority)) => authority,
+        Ok(None) => return Ok(isolated()),
+        Err(PrepareLeaderStartError::PaneAuthorityRefused(_)) if !allow_nested_attach => {
+            // An inherited tuple cannot authorize adoption, but an ordinary
+            // managed launch can still create its own workspace pane. Keep
+            // explicit external/attach and nested-attach intent fail-closed.
+            return Ok(isolated());
+        }
+        Err(error) => return Err(error),
     };
-    let tmux = tmux.into_string().map_err(|_| {
-        PrepareLeaderStartError::PaneAuthorityRefused(ambient_tmux_endpoint_refusal(
-            workspace,
-            pane_refusal::AmbientTmuxEndpointUnavailableCause::TmuxValueNotUnicode,
-        ))
-    })?;
-    let observed_endpoint = validated_ambient_tmux_endpoint(workspace, &tmux)
-        .map_err(PrepareLeaderStartError::PaneAuthorityRefused)?;
-    if provider == Provider::Pi && provider_args.is_empty() && !allow_nested_attach {
-        // Pi's zero-argument managed entry already owns this verified pane as its
-        // user-facing terminal. Replacing the current process is safe on either
-        // the workspace server or another server; switching/attaching would move
-        // the user away from the positively verified workspace pane.
-        let authority = verified_ambient_pane_authority(workspace, &tmux)
-            .map_err(PrepareLeaderStartError::PaneAuthorityRefused)?;
+    if workspace_state_is_managed_provider_reentry(workspace)
+        || (provider == Provider::Pi && provider_args.is_empty() && !allow_nested_attach)
+    {
+        // Only verified current-pane authority permits replacing the caller.
         return Ok((Some(authority), None, true));
     }
-    let target_socket_name = TmuxBackend::for_workspace(workspace)
-        .tmux_endpoint()
-        .ok_or_else(|| LeaderError::Start("workspace tmux endpoint missing".to_string()))?;
     let target_endpoint = crate::tmux_backend::socket_path_for_workspace(workspace);
     let same_server = target_endpoint.as_ref().is_some_and(|target| {
-        let observed = Path::new(&observed_endpoint)
+        let observed = Path::new(&authority.endpoint)
             .canonicalize()
-            .unwrap_or_else(|_| PathBuf::from(&observed_endpoint));
+            .unwrap_or_else(|_| PathBuf::from(&authority.endpoint));
         let target = target.canonicalize().unwrap_or_else(|_| target.clone());
         observed == target
     });
     if same_server {
-        let authority = verified_ambient_pane_authority(workspace, &tmux)
-            .map_err(PrepareLeaderStartError::PaneAuthorityRefused)?;
         return Ok((
             Some(authority),
             Some(ManagedClientAttachMode::SwitchClient),
             false,
         ));
     }
-    if !allow_nested_attach {
-        return Err(LeaderError::Validation(format!(
-            "{DIFFERENT_TMUX_SERVER_PREFIX}: observed_endpoint={observed_endpoint}; \
-             requested_workspace_socket={target_socket_name}"
-        ))
-        .into());
+    if allow_nested_attach {
+        return Ok((
+            Some(authority),
+            Some(ManagedClientAttachMode::AttachSession),
+            false,
+        ));
     }
-    let authority = verified_ambient_pane_authority(workspace, &tmux)
-        .map_err(PrepareLeaderStartError::PaneAuthorityRefused)?;
-    Ok((
-        Some(authority),
-        Some(ManagedClientAttachMode::AttachSession),
-        false,
-    ))
+    // Do not switch/adopt the unrelated server. The existing managed attach
+    // child clears TMUX/TMUX_PANE without changing the caller's environment.
+    Ok(isolated())
 }
 
 fn validated_ambient_tmux_endpoint(

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

@@ -4,7 +4,7 @@ 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,
+    paste_to_submit_floor_for_recipient, recipient_allows_explicit_queue_flush,
     recipient_requires_single_enter,
 };
 use crate::model::enums::{Provider, ProviderEffort};
@@ -186,17 +186,12 @@ fn pi_delivery_submits_one_enter_and_never_flushes_or_retries() {
         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"
-    );
+    // Working native CLIs queue the same single-Enter input; no idle admission.
     assert!(recipient_requires_single_enter(&busy, "worker-a"));
     assert!(!recipient_allows_explicit_queue_flush(&busy, "worker-a"));
 }