@team-agent/installer 0.4.11 → 0.5.0

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

@@ -80,4 +80,23 @@ mod tests {
             assert!(g.as_str().starts_with("tick."));
         }
     }
+
+    #[test]
+    fn ordered_group_labels_are_byte_stable() {
+        let labels = TickStepGroup::ordered()
+            .iter()
+            .map(|group| group.as_str())
+            .collect::<Vec<_>>();
+        assert_eq!(
+            labels,
+            vec![
+                "tick.session_gate",
+                "tick.health_sync",
+                "tick.delivery",
+                "tick.runtime_prompts",
+                "tick.abnormal",
+                "tick.persist",
+            ]
+        );
+    }
 }

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

@@ -1,13 +1,13 @@
 use super::*;
 
 // ═════════════════════════════════════════════════════════════════════════
-// A0 GREEN regression lock, integration tier (save_hook window injection).
+// Phase C stale-save contract, integration tier (save_hook window injection).
 // Locate doc: .team/artifacts/a0-rs-lostupdate-locate.md §5.4.
 //
 // Python 0.2.11 A0: the coordinator tick loads state (tick window opens), mutates in
 // memory for seconds, then whole-file-saves with no merge — an add-agent registration
-// landing inside that window is permanently overwritten (state.py:493). RS blocks this
-// via the in-lock reload+merge at the save chokepoint (persist.rs:210-221, 272-313).
+// landing inside that window is permanently overwritten (state.py:493). Phase C keeps
+// the no-corruption guarantee by refusing stale live topology instead of cloning rows.
 //
 // This test pins the END-TO-END guard through the REAL tick: the `save_hook` seam
 // (tick.rs save point) lets us deterministically land a concurrent registration on disk
@@ -17,7 +17,7 @@ use super::*;
 // ═════════════════════════════════════════════════════════════════════════
 
 #[test]
-fn a0_green_lock_tick_save_preserves_registration_landed_after_tick_load() {
+fn a0_phase_c_tick_save_degrades_on_live_topology_landed_after_tick_load() {
     let dir = std::env::temp_dir().join(format!(
         "team-agent-coord-a0-{}-{}",
         std::process::id(),
@@ -46,6 +46,7 @@ fn a0_green_lock_tick_save_preserves_registration_landed_after_tick_load() {
             serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
         latest["agents"]["joiner"] = serde_json::json!({
             "provider": "codex", "status": "running", "agent_id": "joiner", "window": "joiner",
+            "pane_id": "%9", "spawned_at": "2026-06-01T00:00:00Z", "spawn_epoch": 1,
         });
         std::fs::write(&path, serde_json::to_string_pretty(&latest).unwrap()).unwrap();
         crate::state::projection::save_team_scoped_state(ws.as_path(), tick_state)
@@ -56,7 +57,10 @@ fn a0_green_lock_tick_save_preserves_registration_landed_after_tick_load() {
     let transport = MockTransport::new(true);
     let coord = Coordinator::for_test(ws, reg, Box::new(transport), Some(hook), None);
     let report = coord.tick().expect("tick should complete");
-    assert!(report.ok, "tick must not degrade; report={report:?}");
+    assert!(
+        !report.ok && matches!(report.reason, Some(TickStopReason::PersistenceDegraded)),
+        "stale live topology must degrade this tick and retry from fresh state later; report={report:?}"
+    );
 
     let saved: serde_json::Value = serde_json::from_str(
         &std::fs::read_to_string(crate::state::persist::runtime_state_path(&dir)).unwrap(),
@@ -66,8 +70,7 @@ fn a0_green_lock_tick_save_preserves_registration_landed_after_tick_load() {
         saved
             .pointer("/agents/joiner")
             .is_some_and(serde_json::Value::is_object),
-        "A0 GREEN lock: a registration landing between tick load and tick save must \
-survive the tick's save (in-lock reload+merge, persist.rs:272-313); saved={saved}"
+        "Phase C: concurrent live registration stays on disk; stale tick must not overwrite it; saved={saved}"
     );
     // 0.3.5 integration re-anchor (P3 / perf C-P3-1): the tick iteration counter moved
     // OUT of persistent state into .team/runtime/coordinator_tick.json — state.json is
@@ -85,3 +88,71 @@ survive the tick's save (in-lock reload+merge, persist.rs:272-313); saved={saved
         "the tick really ran (its iteration counter metadata landed); tick_meta={tick_meta}"
     );
 }
+
+#[test]
+fn a0_phase_c_tick_preserves_typed_non_live_roster_stub_only() {
+    let dir = std::env::temp_dir().join(format!(
+        "team-agent-coord-a0-roster-{}-{}",
+        std::process::id(),
+        std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap()
+            .as_nanos()
+    ));
+    std::fs::create_dir_all(&dir).unwrap();
+    crate::state::persist::save_runtime_state(
+        &dir,
+        &serde_json::json!({
+            "session_name": "team-a0",
+            "active_team_key": "team-a0",
+            "agents": { "w1": { "provider": "codex", "status": "running", "agent_id": "w1", "window": "w1" } },
+        }),
+    )
+    .unwrap();
+
+    let hook: SaveHook = Box::new(|ws, tick_state| {
+        let path = crate::state::persist::runtime_state_path(ws.as_path());
+        let mut latest: serde_json::Value =
+            serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
+        latest["agents"]["typed"] = serde_json::json!({
+            "provider": "codex",
+            "role": "Developer",
+            "agent_id": "typed",
+            "status": "running",
+            "spawn_cwd": "/tmp/stale",
+            "session_id": "old-session"
+        });
+        std::fs::write(&path, serde_json::to_string_pretty(&latest).unwrap()).unwrap();
+        crate::state::projection::save_team_scoped_state(ws.as_path(), tick_state)
+    });
+
+    let ws = WorkspacePath::new(dir.clone());
+    let reg: Box<dyn ProviderRegistry> = Box::new(MockRegistry::new(&[], &[]));
+    let transport = MockTransport::new(true);
+    let coord = Coordinator::for_test(ws, reg, Box::new(transport), Some(hook), None);
+    let report = coord.tick().expect("tick should complete");
+    assert!(
+        report.ok,
+        "non-live roster stub must not degrade tick; report={report:?}"
+    );
+
+    let saved: serde_json::Value = serde_json::from_str(
+        &std::fs::read_to_string(crate::state::persist::runtime_state_path(&dir)).unwrap(),
+    )
+    .unwrap();
+    let typed = saved.pointer("/agents/typed").expect("typed roster stub");
+    assert_eq!(
+        typed.get("provider").and_then(serde_json::Value::as_str),
+        Some("codex")
+    );
+    assert_eq!(
+        typed.get("role").and_then(serde_json::Value::as_str),
+        Some("Developer")
+    );
+    for forbidden in ["status", "spawn_cwd", "session_id"] {
+        assert!(
+            typed.get(forbidden).is_none(),
+            "typed roster stub must not preserve forbidden field {forbidden}; typed={typed}"
+        );
+    }
+}

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

@@ -150,6 +150,201 @@ fn abnormal_preseeded_seen_suppresses_duplicate_across_calls() {
     assert_eq!(out.notifications.len(), 0, "pre-seeded seen suppresses (probe: 0)");
 }
 
+#[test]
+fn abnormal_explicit_error_classifier_boundaries_stay_stable() {
+    let claude_api = line(serde_json::json!({
+        "type": "system",
+        "subtype": "api_error",
+        "level": "error",
+        "sessionId": "sess-1"
+    }));
+    let claude_api_fact =
+        crate::provider::latest_explicit_error_fact(Provider::ClaudeCode, &claude_api)
+            .expect("Claude system api_error level=error counts as explicit");
+    assert_eq!(claude_api_fact.signature.as_str(), "api_error");
+    assert_eq!(
+        claude_api_fact.turn_id.as_ref().map(|id| id.as_str()),
+        Some("sess-1")
+    );
+    assert_eq!(claude_api_fact.api_error_status, None);
+    assert_eq!(claude_api_fact.error.as_deref(), None);
+    assert_eq!(claude_api_fact.request_id.as_deref(), None);
+    assert_eq!(claude_api_fact.assistant_uuid.as_deref(), None);
+
+    let claude_400 = line(serde_json::json!({
+        "type": "assistant",
+        "parentUuid": "parent-400",
+        "uuid": "assistant-400",
+        "message": {"role": "assistant", "content": [
+            {"type": "text", "text": "API Error: 400 Team Agent truthsource forced invalid_request_error"}
+        ]},
+        "error": "unknown",
+        "isApiErrorMessage": true,
+        "apiErrorStatus": 400,
+        "sessionId": "session-400",
+        "version": "2.1.181"
+    }));
+    let claude_400_fact =
+        crate::provider::latest_explicit_error_fact(Provider::ClaudeCode, &claude_400)
+            .expect("Claude assistant api error counts as explicit");
+    assert_claude_api_error_fact(
+        &claude_400_fact,
+        "assistant-400",
+        Some(400),
+        Some("unknown"),
+        None,
+        Some("assistant-400"),
+    );
+
+    let claude_404 = line(serde_json::json!({
+        "type": "assistant",
+        "parentUuid": "parent-404",
+        "uuid": "assistant-404",
+        "message": {"role": "assistant", "content": [
+            {"type": "text", "text": "There's an issue with the selected model."}
+        ]},
+        "error": "model_not_found",
+        "isApiErrorMessage": true,
+        "apiErrorStatus": 404,
+        "sessionId": "session-404",
+        "version": "2.1.181"
+    }));
+    let claude_404_fact =
+        crate::provider::latest_explicit_error_fact(Provider::ClaudeCode, &claude_404)
+            .expect("Claude assistant model_not_found counts as explicit");
+    assert_claude_api_error_fact(
+        &claude_404_fact,
+        "assistant-404",
+        Some(404),
+        Some("model_not_found"),
+        None,
+        Some("assistant-404"),
+    );
+
+    let claude_real_request = line(serde_json::json!({
+        "type": "assistant",
+        "parentUuid": "parent-real",
+        "uuid": "assistant-real",
+        "requestId": "req_011CceNfWj2aPY5gtCdakULt",
+        "message": {"role": "assistant", "content": [
+            {"type": "text", "text": "There's an issue with the selected model."}
+        ]},
+        "error": "model_not_found",
+        "isApiErrorMessage": true,
+        "apiErrorStatus": 404,
+        "sessionId": "session-real",
+        "version": "2.1.181"
+    }));
+    let claude_real_fact =
+        crate::provider::latest_explicit_error_fact(Provider::ClaudeCode, &claude_real_request)
+            .expect("Claude assistant api error with requestId counts as explicit");
+    assert_claude_api_error_fact(
+        &claude_real_fact,
+        "assistant-real",
+        Some(404),
+        Some("model_not_found"),
+        Some("req_011CceNfWj2aPY5gtCdakULt"),
+        Some("assistant-real"),
+    );
+
+    let claude_tool_result = line(serde_json::json!({
+        "type": "user",
+        "message": {
+            "content": [
+                {"type": "tool_result", "is_error": true, "content": "permission denied"}
+            ]
+        }
+    }));
+    assert!(
+        crate::provider::latest_explicit_error_fact(Provider::ClaudeCode, &claude_tool_result)
+            .is_none(),
+        "Claude tool_result is_error is an abnormal fact, but not an explicit provider-exit error"
+    );
+
+    let ordinary_assistant_text = line(serde_json::json!({
+        "type": "assistant",
+        "uuid": "assistant-text",
+        "message": {"role": "assistant", "content": [
+            {"type": "text", "text": "The command returned an error string."}
+        ]},
+        "sessionId": "session-text"
+    }));
+    assert!(
+        crate::provider::latest_explicit_error_fact(Provider::ClaudeCode, &ordinary_assistant_text)
+            .is_none(),
+        "ordinary assistant text containing error is not a structured API error"
+    );
+
+    let interrupted = line(serde_json::json!({
+        "type": "user",
+        "uuid": "user-interrupt",
+        "message": {"content": [{"type": "text", "text": "[Request interrupted by user]"}]}
+    }));
+    assert!(
+        crate::provider::latest_explicit_error_fact(Provider::ClaudeCode, &interrupted).is_none(),
+        "user interruption is not a provider API error"
+    );
+
+    let empty_api_error_shape = line(serde_json::json!({
+        "type": "assistant",
+        "uuid": "assistant-empty",
+        "message": {"role": "assistant", "content": [
+            {"type": "text", "text": "API Error:"}
+        ]},
+        "isApiErrorMessage": true,
+        "sessionId": "session-empty"
+    }));
+    assert!(
+        crate::provider::latest_explicit_error_fact(Provider::ClaudeCode, &empty_api_error_shape)
+            .is_none(),
+        "isApiErrorMessage without status/error/requestId is not enough"
+    );
+
+    let codex_failed = line(serde_json::json!({
+        "jsonrpc": "2.0",
+        "method": "turn/completed",
+        "params": {"turn": {"id": "turn-1", "status": "failed"}}
+    }));
+    let codex_fact = crate::provider::latest_explicit_error_fact(Provider::Codex, &codex_failed)
+        .expect("Codex failed turn/completed counts as explicit");
+    assert_eq!(codex_fact.signature.as_str(), "turn_failed");
+    assert_eq!(
+        codex_fact.turn_id.as_ref().map(|id| id.as_str()),
+        Some("turn-1")
+    );
+
+    let non_error = line(serde_json::json!({
+        "jsonrpc": "2.0",
+        "method": "turn/completed",
+        "params": {"turn": {"id": "turn-2", "status": "completed"}}
+    }));
+    assert!(
+        crate::provider::latest_explicit_error_fact(Provider::Codex, &non_error).is_none(),
+        "non-error tail must not count as latest explicit error"
+    );
+}
+
+fn line(value: serde_json::Value) -> String {
+    format!("{value}\n")
+}
+
+fn assert_claude_api_error_fact(
+    fact: &crate::provider::FaultFact,
+    turn_id: &str,
+    status: Option<i64>,
+    error: Option<&str>,
+    request_id: Option<&str>,
+    assistant_uuid: Option<&str>,
+) {
+    assert_eq!(fact.signature.as_str(), "api_error");
+    assert_eq!(fact.kind, crate::provider::FactKind::Error);
+    assert_eq!(fact.turn_id.as_ref().map(|id| id.as_str()), Some(turn_id));
+    assert_eq!(fact.api_error_status, status);
+    assert_eq!(fact.error.as_deref(), error);
+    assert_eq!(fact.request_id.as_deref(), request_id);
+    assert_eq!(fact.assistant_uuid.as_deref(), assistant_uuid);
+}
+
 // ═════════════════════════════════════════════════════════════════════════
 // GROUP F — detect_whole_team_gone (abnormal_track.py:91) — clean vs unexpected — RED
 // ═════════════════════════════════════════════════════════════════════════