@team-agent/installer 0.5.34 → 0.5.36

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

@@ -223,7 +223,22 @@ pub fn execute_leader_plan(
         && !std::io::stdin().is_terminal()
         && insert_detach_flag(&mut argv);
     if plan.mode == LeaderStartMode::ExecProvider && !plan.is_external_leader {
-        persist_exec_provider_leader_binding(plan, workspace)?;
+        // 0.5.35 (`.team/artifacts/managed-leader-provider-reentry-locate.md`
+        // §5/§6): three-way classify BEFORE persist. Same physical pane =
+        // provider process replacement (refresh only). Different pane with
+        // an existing canonical binding = no canonical rewrite (claim /
+        // takeover is the recovery path, §7). Unbound = first-time write.
+        match classify_exec_provider_binding(workspace, plan)? {
+            ExecProviderBinding::ManagedReentry => {
+                refresh_managed_leader_provider_binding(plan, workspace)?;
+            }
+            ExecProviderBinding::DifferentPaneAlreadyBound => {
+                // No canonical state write. Provider still runs below.
+            }
+            ExecProviderBinding::Unbound => {
+                persist_exec_provider_leader_binding(plan, workspace)?;
+            }
+        }
     } else if plan.is_external_leader {
         persist_external_leader_topology_marker(plan, workspace)?;
     }
@@ -904,6 +919,184 @@ fn persist_exec_provider_leader_binding(
     Ok(())
 }
 
+/// 0.5.35 (`.team/artifacts/managed-leader-provider-reentry-locate.md` §5/§6):
+/// three-way classification of an in-tmux ExecProvider invocation. Physical-
+/// channel-first — never consults `pane_current_command` or gates on
+/// `leader_session_uuid` equality (§6 forbids uuid-mismatch hard refusal).
+enum ExecProviderBinding {
+    ManagedReentry,
+    DifferentPaneAlreadyBound,
+    Unbound,
+}
+
+fn classify_exec_provider_binding(
+    workspace: &Path,
+    plan: &LeaderStartPlan,
+) -> Result<ExecProviderBinding, LeaderError> {
+    let Some(pane) = std::env::var("TMUX_PANE")
+        .ok()
+        .filter(|value| !value.trim().is_empty())
+    else {
+        return Ok(ExecProviderBinding::Unbound);
+    };
+    let state = match crate::state::persist::load_runtime_state(workspace) {
+        Ok(state) => state,
+        Err(_) => return Ok(ExecProviderBinding::Unbound),
+    };
+    let team_key = plan
+        .identity
+        .as_ref()
+        .map(|identity| identity.team_id.as_str().to_string())
+        .or_else(|| {
+            state
+                .get("active_team_key")
+                .and_then(serde_json::Value::as_str)
+                .filter(|s| !s.is_empty())
+                .map(str::to_string)
+        });
+    let Some(team_key) = team_key else {
+        return Ok(ExecProviderBinding::Unbound);
+    };
+    let Some(receiver) = state
+        .pointer(&format!("/teams/{team_key}/leader_receiver"))
+        .and_then(serde_json::Value::as_object)
+    else {
+        return Ok(ExecProviderBinding::Unbound);
+    };
+    let receiver_pane = receiver
+        .get("pane_id")
+        .or_else(|| receiver.get("pane"))
+        .and_then(serde_json::Value::as_str)
+        .unwrap_or("");
+    if receiver_pane.is_empty() {
+        return Ok(ExecProviderBinding::Unbound);
+    }
+    if receiver_pane != pane {
+        return Ok(ExecProviderBinding::DifferentPaneAlreadyBound);
+    }
+    let pane_id = PaneId::new(pane.clone());
+    let target = current_tmux_pane_info(&pane_id);
+    let leader_prefixed_session = target
+        .as_ref()
+        .map(|t| t.session.as_str().starts_with(LEADER_SESSION_PREFIX))
+        .unwrap_or(false);
+    if !leader_prefixed_session {
+        return Ok(ExecProviderBinding::DifferentPaneAlreadyBound);
+    }
+    let recorded_socket = receiver
+        .get("tmux_socket")
+        .and_then(serde_json::Value::as_str)
+        .filter(|s| !s.is_empty());
+    if let Some(recorded_socket) = recorded_socket {
+        let caller_socket = crate::tmux_backend::socket_name_from_tmux_env();
+        if caller_socket.as_deref() != Some(recorded_socket) {
+            return Ok(ExecProviderBinding::DifferentPaneAlreadyBound);
+        }
+    }
+    Ok(ExecProviderBinding::ManagedReentry)
+}
+
+/// 0.5.35: same-pane provider re-entry refresh path. Preserves canonical
+/// team runtime identity (`session_name`/`team_dir`/`spec_path`/`agents`/
+/// `tasks`) and epoch non-regressively; updates only diagnostic receiver
+/// fields. Stage 3 strip preserved (root `team_owner`/`leader_receiver`/
+/// `owner_epoch` are NOT reintroduced — writes go through
+/// `state::ownership::write_owner` into the canonical teams.<key> slot).
+fn refresh_managed_leader_provider_binding(
+    plan: &LeaderStartPlan,
+    workspace: &Path,
+) -> Result<(), LeaderError> {
+    let identity = plan
+        .identity
+        .as_ref()
+        .ok_or_else(|| LeaderError::Start("managed leader re-entry identity missing".to_string()))?;
+    let pane = std::env::var("TMUX_PANE")
+        .ok()
+        .filter(|value| !value.trim().is_empty())
+        .ok_or_else(|| LeaderError::Start("managed leader re-entry pane missing".to_string()))?;
+    let pane_id = PaneId::new(pane.clone());
+    let target = current_tmux_pane_info(&pane_id);
+    let mut state = crate::state::persist::load_runtime_state(workspace)
+        .unwrap_or_else(|_| serde_json::json!({}));
+    let team_key = identity.team_id.as_str();
+    let existing_receiver = state
+        .pointer(&format!("/teams/{team_key}/leader_receiver"))
+        .cloned()
+        .unwrap_or_else(|| serde_json::json!({}));
+    let existing_owner = crate::state::ownership::read_owner_value(&state, team_key)
+        .cloned()
+        .unwrap_or_else(|| serde_json::json!({}));
+    let existing_epoch = state
+        .pointer(&format!("/teams/{team_key}/owner_epoch"))
+        .and_then(serde_json::Value::as_u64)
+        .or_else(|| existing_owner.get("owner_epoch").and_then(serde_json::Value::as_u64))
+        .or_else(|| existing_receiver.get("owner_epoch").and_then(serde_json::Value::as_u64))
+        .unwrap_or(0);
+    let now = chrono::Utc::now().to_rfc3339();
+    let provider = serde_json::to_value(plan.provider)?;
+    let mut receiver = match existing_receiver.as_object() {
+        Some(map) => serde_json::Value::Object(map.clone()),
+        None => serde_json::json!({}),
+    };
+    if let Some(obj) = receiver.as_object_mut() {
+        obj.insert("mode".to_string(), serde_json::json!("direct_tmux"));
+        obj.insert("status".to_string(), serde_json::json!("attached"));
+        obj.insert("provider".to_string(), provider.clone());
+        obj.insert("pane_id".to_string(), serde_json::json!(pane));
+        obj.insert("pane".to_string(), serde_json::json!(pane));
+        obj.insert("attached_at".to_string(), serde_json::json!(now.clone()));
+        obj.insert("discovery".to_string(), serde_json::json!("managed_leader"));
+        obj.insert("owner_epoch".to_string(), serde_json::json!(existing_epoch));
+        obj.entry("leader_session_uuid".to_string())
+            .or_insert_with(|| serde_json::json!(identity.leader_session_uuid.as_str()));
+        if let Some(target) = target.as_ref() {
+            obj.insert("session_name".to_string(), serde_json::json!(target.session.as_str()));
+            if let Some(window_name) = target.window_name.as_ref() {
+                obj.insert("window_name".to_string(), serde_json::json!(window_name.as_str()));
+            }
+            if let Some(pane_pid) = target.pane_pid {
+                obj.insert("pane_pid".to_string(), serde_json::json!(pane_pid));
+            }
+        }
+    }
+    let mut owner = match existing_owner.as_object() {
+        Some(map) => serde_json::Value::Object(map.clone()),
+        None => serde_json::json!({}),
+    };
+    if let Some(obj) = owner.as_object_mut() {
+        obj.insert("pane_id".to_string(), serde_json::json!(pane));
+        obj.insert("provider".to_string(), provider);
+        obj.insert("owner_epoch".to_string(), serde_json::json!(existing_epoch));
+        obj.entry("machine_fingerprint".to_string())
+            .or_insert_with(|| serde_json::json!(identity.machine_fingerprint.as_str()));
+        obj.entry("leader_session_uuid".to_string())
+            .or_insert_with(|| serde_json::json!(identity.leader_session_uuid.as_str()));
+        obj.entry("claimed_via".to_string())
+            .or_insert_with(|| serde_json::json!("claim-leader"));
+        obj.entry("os_user".to_string())
+            .or_insert_with(|| serde_json::json!(identity.os_user.as_str()));
+    }
+    if let Some(obj) = state.as_object_mut() {
+        obj.insert("active_team_key".to_string(), serde_json::json!(team_key));
+        obj.insert(
+            "leader_client".to_string(),
+            serde_json::json!({
+                "diagnostic_only": true,
+                "attach_mode": "exec-provider",
+                "tmux": std::env::var("TMUX").ok(),
+                "reentry": true,
+            }),
+        );
+    }
+    let record = crate::state::ownership::OwnershipWrite::new()
+        .with_leader_receiver(receiver)
+        .with_team_owner(owner)
+        .with_owner_epoch(existing_epoch);
+    crate::state::ownership::write_owner(&mut state, team_key, record);
+    crate::state::persist::save_runtime_state(workspace, &state)?;
+    Ok(())
+}
+
 fn current_tmux_pane_info(pane_id: &PaneId) -> Option<crate::transport::PaneInfo> {
     tmux_transport_for_current_pane()
         .list_targets()

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

@@ -795,6 +795,71 @@ pub fn stop_agent_with_transport(
     )
 }
 
+/// 0.5.36 (`.team/artifacts/supermarket-api-error-recovery-locate.md` §7.3/§7.4):
+/// api_error recovery entry point. Runs post-atomic_save from coordinator
+/// tick to replace the stuck provider process on a retryable outage. It
+/// resolves lifecycle paths, force-stops the live pane if the worker is
+/// still alive (so `start_agent_at_paths(force=true)` cannot be a Noop —
+/// see R3 contract), then starts the agent with `allow_fresh=false` to
+/// preserve session context. Returns a small, typed outcome so the
+/// caller only needs the delta for event emission; the underlying
+/// lifecycle helpers own their state saves.
+pub(crate) fn start_agent_at_paths_for_recovery(
+    workspace: &Path,
+    agent_id: &AgentId,
+    team: Option<&str>,
+    transport: &dyn crate::transport::Transport,
+) -> Result<
+    crate::coordinator::steps::abnormal::RecoveryLifecycleOutcome,
+    crate::coordinator::steps::abnormal::RecoveryError,
+> {
+    use crate::coordinator::steps::abnormal::{RecoveryError, RecoveryLifecycleOutcome};
+    let paths = match lifecycle_paths(workspace, team) {
+        Ok(paths) => paths,
+        Err(_) if team.is_none() => LifecyclePaths {
+            run_workspace: workspace.to_path_buf(),
+            spec_workspace: workspace.to_path_buf(),
+        },
+        Err(error) => return Err(RecoveryError::Lifecycle(error.to_string())),
+    };
+    // Best-effort stop: if the live pane still exists we tear it down so the
+    // subsequent start creates a fresh provider process instead of a Noop.
+    // Stop errors are absorbed into the start attempt result — the important
+    // invariant is that a successful start returns Running, never Noop.
+    let _ = stop_agent_with_transport(
+        &paths.run_workspace,
+        agent_id,
+        team,
+        transport,
+    );
+    let start_result = start_agent_with_transport(
+        &paths.run_workspace,
+        agent_id,
+        /* force */ true,
+        /* open_display */ false,
+        /* allow_fresh */ false,
+        team,
+        transport,
+    );
+    match start_result {
+        Ok(StartAgentOutcome::Running {
+            start_mode,
+            target,
+            env,
+            ..
+        }) => Ok(RecoveryLifecycleOutcome {
+            start_mode: format!("{:?}", start_mode),
+            target,
+            coordinator_started: env.coordinator_started,
+        }),
+        Ok(StartAgentOutcome::Noop { .. }) => Err(RecoveryError::NoopBlocked),
+        Ok(StartAgentOutcome::Paused { .. }) => Err(RecoveryError::Lifecycle(
+            "agent is paused; recovery skipped".to_string(),
+        )),
+        Err(error) => Err(RecoveryError::Lifecycle(error.to_string())),
+    }
+}
+
 pub(super) fn stop_agent_at_paths(
     workspace: &Path,
     spec_workspace: &Path,

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

@@ -33,6 +33,10 @@ mod selection;
 mod team_state;
 
 pub(crate) use agent::start_agent_at_paths;
+// 0.5.36 supermarket api_error recovery: coordinator post-save step calls
+// this to replace a stuck provider process without going through the
+// public start-agent CLI path.
+pub(crate) use agent::start_agent_at_paths_for_recovery;
 pub use agent::{
     reset_agent, reset_agent_with_transport, start_agent, start_agent_with_transport, stop_agent,
     stop_agent_with_transport,

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

@@ -168,6 +168,14 @@ pub enum StateWriteIntent<'a> {
     CoordinatorConptyShim {
         team_key: Option<&'a str>,
     },
+    /// 0.5.36 (`.team/artifacts/supermarket-api-error-recovery-locate.md` §7.3):
+    /// post-save recovery step writes back the recovery intent outcome
+    /// (attempts / status / last_error / blocked_reason). Distinct intent
+    /// so future S1b migration can route it deliberately.
+    CoordinatorApiErrorRecovery {
+        team_key: Option<&'a str>,
+        agent_id: &'a str,
+    },
     McpAssignTask {
         team_key: Option<&'a str>,
         task_id: &'a str,
@@ -311,6 +319,13 @@ fn route_direct(
         // CoordinatorConptyShim -> root save
         // (coordinator/conpty_shim.rs:426/674).
         StateWriteIntent::CoordinatorConptyShim { .. } => helper_write_root(workspace, state),
+        // 0.5.36 CoordinatorApiErrorRecovery -> root save. The recovery
+        // intent lives under `coordinator.abnormal_api_error_recovery`, a
+        // root-scoped bookkeeping namespace that must survive across team
+        // boundaries; use the same helper family as CoordinatorConptyShim.
+        StateWriteIntent::CoordinatorApiErrorRecovery { .. } => {
+            helper_write_root(workspace, state)
+        }
         // McpAssignTask uses the reapply variant today; direct save routes
         // to the root helper for parity.
         StateWriteIntent::McpAssignTask { .. } => helper_write_root(workspace, state),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.5.34",
+  "version": "0.5.36",
   "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.34",
-    "@team-agent/cli-darwin-x64": "0.5.34",
-    "@team-agent/cli-linux-x64": "0.5.34"
+    "@team-agent/cli-darwin-arm64": "0.5.36",
+    "@team-agent/cli-darwin-x64": "0.5.36",
+    "@team-agent/cli-linux-x64": "0.5.36"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",