@team-agent/installer 0.5.36 → 0.5.37

package/Cargo.lock

@@ -575,7 +575,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.36"
+version = "0.5.37"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent", "crates/win-conpty-phase0", "crates/conpty-trans
 
 [workspace.package]
 edition = "2021"
-version = "0.5.36"
+version = "0.5.37"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

package/crates/team-agent/src/coordinator/steps/abnormal.rs

@@ -1703,6 +1703,13 @@ pub(crate) fn attempt_due_recoveries(
     let Ok(state) = crate::state::persist::load_runtime_state(workspace) else {
         return;
     };
+    // 0.5.37 (`architect res_b8a6d40f3765`, R8): clear stale `next_retry_at`
+    // on terminal intents (succeeded/blocked/exhausted) BEFORE dispatching.
+    // Without this, a terminal record whose past `next_retry_at` survives
+    // a coordinator restart could get re-dispatched on the next tick,
+    // producing a spurious `recovery_started` event for an intent whose
+    // lifecycle already completed.
+    clear_stale_terminal_next_retry_at(workspace);
     let due_agents = collect_due_recovery_agents(&state);
     for agent_id in due_agents {
         run_single_recovery(workspace, event_log, transport, &agent_id);
@@ -1723,7 +1730,12 @@ fn collect_due_recovery_agents(state: &Value) -> Vec<String> {
             .get("status")
             .and_then(Value::as_str)
             .unwrap_or("");
-        if !matches!(status, "scheduled") {
+        // 0.5.37 R8: dispatch only for non-terminal states. `succeeded`,
+        // `blocked`, `exhausted`, `backpressured` are terminal / awaiting
+        // manual action — a lifecycle dispatch here would be double-fire
+        // or wasted work. `scheduled` / `running` remain dispatchable so
+        // an interrupted tick can resume.
+        if !matches!(status, "scheduled" | "running") {
             continue;
         }
         let Some(next_retry_at) = intent
@@ -1741,6 +1753,44 @@ fn collect_due_recovery_agents(state: &Value) -> Vec<String> {
     due
 }
 
+/// 0.5.37 (`architect res_b8a6d40f3765`, R8): terminal recovery states
+/// (`succeeded`, `blocked`, `exhausted`) must not carry a stale
+/// `next_retry_at`. Load state, scrub the key on any terminal entry, and
+/// only persist when at least one row changed so we don't dirty the tick's
+/// atomic_save contract for idle workspaces.
+fn clear_stale_terminal_next_retry_at(workspace: &Path) {
+    let Ok(mut state) = crate::state::persist::load_runtime_state(workspace) else {
+        return;
+    };
+    let mut mutated = false;
+    if let Some(agents) = recovery_intent_agents(&mut state) {
+        for (_agent_id, entry) in agents.iter_mut() {
+            let Some(obj) = entry.as_object_mut() else {
+                continue;
+            };
+            let status = obj
+                .get("status")
+                .and_then(Value::as_str)
+                .unwrap_or("")
+                .to_string();
+            if !matches!(status.as_str(), "succeeded" | "blocked" | "exhausted") {
+                continue;
+            }
+            let had_stale = obj
+                .get("next_retry_at")
+                .filter(|v| !v.is_null())
+                .is_some();
+            if had_stale {
+                obj.remove("next_retry_at");
+                mutated = true;
+            }
+        }
+    }
+    if mutated {
+        let _ = crate::state::persist::save_runtime_state(workspace, &state);
+    }
+}
+
 fn run_single_recovery(
     workspace: &Path,
     event_log: &EventLog,
@@ -1916,6 +1966,12 @@ fn write_recovery_intent_result(workspace: &Path, agent_id: &str, update: Recove
                     obj.remove("blocked_reason");
                 }
             }
+            // 0.5.37 R8: transitioning into a terminal state clears the
+            // stale `next_retry_at`; a future retry earns a fresh due
+            // time when it re-enters `scheduled` through the detector.
+            if matches!(update.status, "succeeded" | "blocked" | "exhausted") {
+                obj.remove("next_retry_at");
+            }
         }
     }
     let _ = crate::state::persist::save_runtime_state(workspace, &state);

package/crates/team-agent/src/coordinator/tests/api_error_recovery.rs

@@ -257,6 +257,50 @@ fn r7_recovery_never_synthesizes_hidden_provider_turn_or_sdk_call() {
     );
 }
 
+#[test]
+fn r8_terminal_recovery_intents_are_idempotent_and_clear_due_time() {
+    for status in ["succeeded", "blocked", "exhausted"] {
+        let case = RecoveryCase::new(&format!("r8-terminal-{status}"));
+        case.seed_agents(&[("fe-admin", 429, "rate_limit", "baseline-429")]);
+        case.seed_due_recovery_with_status("fe-admin", status);
+
+        run_due_recoveries(&case);
+
+        let events = case.events();
+        assert!(
+            find_event(&events, "worker.abnormal_exit.recovery_started").is_none(),
+            "R8: terminal status `{status}` with stale next_retry_at must be skipped before lifecycle dispatch; events={events:?}"
+        );
+        let state = case.state();
+        let recovery = state
+            .pointer("/coordinator/abnormal_api_error_recovery/agents/fe-admin")
+            .expect("R8: terminal recovery entry remains auditable");
+        assert_eq!(recovery["status"], serde_json::json!(status));
+        assert!(
+            recovery.get("next_retry_at").is_none()
+                || recovery.get("next_retry_at") == Some(&serde_json::Value::Null),
+            "R8: terminal status `{status}` must clear stale next_retry_at so future ticks cannot reuse it; recovery={recovery}"
+        );
+    }
+}
+
+#[test]
+fn r8_non_terminal_due_intents_still_dispatch() {
+    for status in ["scheduled", "running"] {
+        let case = RecoveryCase::new(&format!("r8-nonterminal-{status}"));
+        case.seed_agents(&[("fe-admin", 429, "rate_limit", "baseline-429")]);
+        case.seed_due_recovery_with_status("fe-admin", status);
+
+        run_due_recoveries(&case);
+
+        let events = case.events();
+        assert!(
+            find_event(&events, "worker.abnormal_exit.recovery_started").is_some(),
+            "R8: non-terminal status `{status}` with due next_retry_at must still dispatch recovery; events={events:?}"
+        );
+    }
+}
+
 struct RecoveryCase {
     root: std::path::PathBuf,
 }
@@ -328,11 +372,15 @@ impl RecoveryCase {
     }
 
     fn seed_due_recovery(&self, agent: &str) {
+        self.seed_due_recovery_with_status(agent, "scheduled");
+    }
+
+    fn seed_due_recovery_with_status(&self, agent: &str, status: &str) {
         let mut state = self.state();
         state["coordinator"]["abnormal_api_error_recovery"]["agents"][agent] = serde_json::json!({
             "error_key": format!("worker.abnormal_exit.error:{agent}:rollout:api_error:seed"),
             "cohort_key": "research:claude_code:api_error:429:rate_limit",
-            "status": "scheduled",
+            "status": status,
             "attempts": 0,
             "max_attempts": 2,
             "next_retry_at": "2000-01-01T00:00:00Z",
@@ -478,3 +526,11 @@ fn detect_abnormal_body() -> String {
         .expect("derive after detect_abnormal_exits");
     source[start..end].to_string()
 }
+
+fn run_due_recoveries(case: &RecoveryCase) {
+    crate::coordinator::steps::abnormal::attempt_due_recoveries(
+        &case.root,
+        &crate::event_log::EventLog::new(&case.root),
+        &MockTransport::new(true),
+    );
+}

package/package.json

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