@team-agent/installer 0.5.60 → 0.5.62

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

@@ -1,179 +1,5 @@
 use super::*;
 
-// ═════════════════════════════════════════════════════════════════════════
-// GROUP E — abnormal_track classify / dedup (abnormal_track.py) — RED
-//   provider-neutral:断言 ZERO adapter_for 调用(MUST-NOT-13)。
-//   ASSUMPTION:传入 `records` 是 provider reader 已产出的结构化 fault facts
-//   ({signature, turn_id?, kind?, raw}),即 read_fault_facts 的输出形;abnormal_track
-//   只对它做 catch-bias + (signature, turn_id|fingerprint) 去重(error_lists 来自注入
-//   registry,绝不经 adapter_for 触碰 provider client)。
-// ═════════════════════════════════════════════════════════════════════════
-
-#[test]
-fn abnormal_default_notify_for_structured_fault() {
-    // abnormal_track.py:204 — C9 catch-bias: 无黑白名单命中 → notify_default.
-    let reg = MockRegistry::new(&[], &[]);
-    let records = vec![serde_json::json!({"raw": "session line"})];
-    let out = process_abnormal_records(
-        &records,
-        &reg,
-        Provider::Codex,
-        &AbnormalNotificationState::default(),
-    )
-    .unwrap();
-    assert_eq!(out.notifications.len(), 1);
-    assert_eq!(
-        out.notifications[0].decision,
-        AbnormalDecision::NotifyDefault
-    );
-    // §84:绝不触碰 provider adapter client。
-    assert_eq!(
-        reg.adapter_calls.get(),
-        0,
-        "MUST NOT call adapter_for (provider client)"
-    );
-}
-
-#[test]
-fn abnormal_blacklist_hit_yields_notify_blacklist() {
-    // abnormal_track.py:203 — blacklist 命中 → notify_blacklist.
-    let reg = MockRegistry::new(&[], &["boom"]);
-    let records = vec![serde_json::json!({"raw": "kaboom: boom happened"})];
-    let out = process_abnormal_records(
-        &records,
-        &reg,
-        Provider::Codex,
-        &AbnormalNotificationState::default(),
-    )
-    .unwrap();
-    assert_eq!(out.notifications.len(), 1);
-    assert_eq!(
-        out.notifications[0].decision,
-        AbnormalDecision::NotifyBlacklist
-    );
-    assert_eq!(reg.adapter_calls.get(), 0);
-}
-
-#[test]
-fn abnormal_whitelist_beats_blacklist_and_skips() {
-    // abnormal_track.py:200-201 — whitelist > blacklist > default. 同命中 → skip, 0 notify.
-    let reg = MockRegistry::new(&["boom"], &["boom"]);
-    let records = vec![serde_json::json!({"raw": "boom transient"})];
-    let out = process_abnormal_records(
-        &records,
-        &reg,
-        Provider::Codex,
-        &AbnormalNotificationState::default(),
-    )
-    .unwrap();
-    assert_eq!(
-        out.notifications.len(),
-        0,
-        "whitelist wins → skip (probe confirmed)"
-    );
-    assert_eq!(reg.adapter_calls.get(), 0);
-}
-
-#[test]
-fn abnormal_approval_kind_maps_to_blocked_on_human() {
-    // abnormal_track.py:74 — kind=="approval" → state blocked_on_human, else abnormal.
-    let reg = MockRegistry::new(&[], &[]);
-    let records = vec![serde_json::json!({"raw": "approve?", "kind": "approval"})];
-    let out = process_abnormal_records(
-        &records,
-        &reg,
-        Provider::Codex,
-        &AbnormalNotificationState::default(),
-    )
-    .unwrap();
-    assert_eq!(out.notifications.len(), 1);
-    assert_eq!(out.notifications[0].state, TurnState::BlockedOnHuman);
-}
-
-#[test]
-fn abnormal_same_turn_id_folds_to_one_notification() {
-    // abnormal_track.py:60-68 — C8 dedup: same (signature, turn_id) → one notify.
-    let reg = MockRegistry::new(&[], &[]);
-    let records = vec![
-        serde_json::json!({"signature": "sig_a", "turn_id": "t1", "raw": "boom"}),
-        serde_json::json!({"signature": "sig_a", "turn_id": "t1", "raw": "boom"}),
-    ];
-    let out = process_abnormal_records(
-        &records,
-        &reg,
-        Provider::Codex,
-        &AbnormalNotificationState::default(),
-    )
-    .unwrap();
-    assert_eq!(
-        out.notifications.len(),
-        1,
-        "retry-loop in SAME turn folds (probe: 1)"
-    );
-    // seen 状态回存,key = "sig_a\0t1"。
-    assert!(out.notification_state.seen.contains("sig_a\u{0}t1"));
-}
-
-#[test]
-fn abnormal_missing_turn_id_distinct_faults_each_notify() {
-    // abnormal_track.py:64 — turn_id None → per-record content fingerprint bucket:
-    // 不同 fault 各自 notify(绝不折叠进全局桶,probe: 2)。
-    let reg = MockRegistry::new(&[], &[]);
-    let records = vec![
-        serde_json::json!({"signature": "sig_b", "raw": "alpha"}),
-        serde_json::json!({"signature": "sig_b", "raw": "beta"}),
-    ];
-    let out = process_abnormal_records(
-        &records,
-        &reg,
-        Provider::Codex,
-        &AbnormalNotificationState::default(),
-    )
-    .unwrap();
-    assert_eq!(
-        out.notifications.len(),
-        2,
-        "distinct raw → 2 notifies (probe)"
-    );
-}
-
-#[test]
-fn abnormal_missing_turn_id_identical_faults_fold() {
-    // abnormal_track.py:64-68 — identical raw + missing turn_id → same fingerprint → fold (probe: 1).
-    let reg = MockRegistry::new(&[], &[]);
-    let records = vec![
-        serde_json::json!({"signature": "sig_c", "raw": "same"}),
-        serde_json::json!({"signature": "sig_c", "raw": "same"}),
-    ];
-    let out = process_abnormal_records(
-        &records,
-        &reg,
-        Provider::Codex,
-        &AbnormalNotificationState::default(),
-    )
-    .unwrap();
-    assert_eq!(
-        out.notifications.len(),
-        1,
-        "identical raw folds even w/o turn_id (probe)"
-    );
-}
-
-#[test]
-fn abnormal_preseeded_seen_suppresses_duplicate_across_calls() {
-    // abnormal_track.py:67 — key already in seen → skip notification (cross-tick dedup).
-    let reg = MockRegistry::new(&[], &[]);
-    let mut state = AbnormalNotificationState::default();
-    state.seen.insert("sig_a\u{0}t1".to_string());
-    let records = vec![serde_json::json!({"signature": "sig_a", "turn_id": "t1", "raw": "boom"})];
-    let out = process_abnormal_records(&records, &reg, Provider::Codex, &state).unwrap();
-    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!({

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

@@ -447,7 +447,6 @@ impl Drop for RecoveryCase {
 #[derive(Clone)]
 struct CounterState {
     adapter_calls: Arc<AtomicU32>,
-    error_list_calls: Arc<AtomicU32>,
 }
 
 struct CountingRegistry {
@@ -459,7 +458,6 @@ impl CountingRegistry {
         Self {
             counters: CounterState {
                 adapter_calls: Arc::new(AtomicU32::new(0)),
-                error_list_calls: Arc::new(AtomicU32::new(0)),
             },
         }
     }
@@ -474,13 +472,6 @@ impl ProviderRegistry for CountingRegistry {
         self.counters.adapter_calls.fetch_add(1, Ordering::SeqCst);
         crate::provider::get_adapter(provider)
     }
-
-    fn error_lists(&self, _provider: Provider) -> ErrorLists {
-        self.counters
-            .error_list_calls
-            .fetch_add(1, Ordering::SeqCst);
-        ErrorLists::default()
-    }
 }
 
 fn claude_api_error_line(uuid: &str, status: i64, error: &str) -> String {

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

@@ -98,18 +98,6 @@ fn status_enums_serialize_to_exact_python_strings() {
             serde_json::to_string(&MetadataSource::Start).unwrap(),
             "\"start\"",
         ),
-        (
-            serde_json::to_string(&AbnormalDecision::Skip).unwrap(),
-            "\"skip\"",
-        ),
-        (
-            serde_json::to_string(&AbnormalDecision::NotifyBlacklist).unwrap(),
-            "\"notify_blacklist\"",
-        ),
-        (
-            serde_json::to_string(&AbnormalDecision::NotifyDefault).unwrap(),
-            "\"notify_default\"",
-        ),
         (
             serde_json::to_string(&WholeTeamGoneClass::Alive).unwrap(),
             "\"alive\"",
@@ -132,178 +120,6 @@ fn status_enums_serialize_to_exact_python_strings() {
     }
 }
 
-#[test]
-fn coordinator_event_tags_are_byte_stable() {
-    // 逐一钉 events.jsonl tag(events.py 稳定契约)。
-    let pid = Pid(4242);
-    let cases: Vec<(CoordinatorEvent, &str)> = vec![
-        (
-            CoordinatorEvent::Boot {
-                workspace: "/w".into(),
-                once: true,
-            },
-            "coordinator.boot",
-        ),
-        (
-            CoordinatorEvent::Started {
-                pid,
-                log: "/l".into(),
-            },
-            "coordinator.started",
-        ),
-        (CoordinatorEvent::Stopped { pid }, "coordinator.stopped"),
-        (CoordinatorEvent::Exit { stop: true }, "coordinator.exit"),
-        (
-            CoordinatorEvent::SessionMissing {
-                session: "s".into(),
-            },
-            "coordinator.session_missing",
-        ),
-        (
-            CoordinatorEvent::OrphanSelfTerminate {
-                initial_ppid: 9,
-                current_ppid: 1,
-                workspace: "/w".into(),
-            },
-            "coordinator.orphan_self_terminate",
-        ),
-        (
-            CoordinatorEvent::TickError {
-                error: "boom".into(),
-                exc_type: "OSError".into(),
-                consecutive_failures: 1,
-                next_sleep_sec: 5.0,
-            },
-            "coordinator.tick_error",
-        ),
-        (
-            CoordinatorEvent::TickErrorSuppressed {
-                consecutive_failures: 2,
-                next_sleep_sec: 10.0,
-            },
-            "coordinator.tick_error.suppressed",
-        ),
-        (
-            CoordinatorEvent::TickRecovered {
-                consecutive_failures: 3,
-            },
-            "coordinator.tick_recovered",
-        ),
-        (
-            CoordinatorEvent::RestartIncompatible {
-                pid: Some(pid),
-                expected_protocol: 2,
-                expected_schema: 3,
-            },
-            "coordinator.restart_incompatible",
-        ),
-        (
-            CoordinatorEvent::RestartIncompatibleStopFailed { pid: Some(pid) },
-            "coordinator.restart_incompatible_stop_failed",
-        ),
-        (
-            CoordinatorEvent::SchemaIncompatible {
-                table: Some("messages".into()),
-                missing_columns: vec!["owner_team_id".into()],
-            },
-            "coordinator.schema_incompatible",
-        ),
-        (
-            CoordinatorEvent::IdleTakeoverUnknownPersistent {
-                node_id: "w1".into(),
-                provider: Some(Provider::Codex),
-                auth_mode: None,
-                consecutive_ticks: 60,
-                rollout_path: None,
-            },
-            "idle_takeover.unknown_persistent",
-        ),
-        (
-            CoordinatorEvent::AbnormalNotify {
-                signature: "sig".into(),
-                turn_id: None,
-                decision: AbnormalDecision::NotifyDefault,
-            },
-            "abnormal.notify",
-        ),
-        (
-            CoordinatorEvent::AbnormalWholeTeamGone {
-                classification: WholeTeamGoneClass::UnexpectedExit,
-            },
-            "abnormal.whole_team_gone",
-        ),
-        (
-            CoordinatorEvent::LeaderNotificationLogPruned { removed: 7 },
-            "leader_notification.log_pruned",
-        ),
-        (
-            CoordinatorEvent::LeaderNotificationPruneFailed { error: "io".into() },
-            "leader_notification.prune_failed",
-        ),
-        (
-            CoordinatorEvent::RuntimeStateSaveFailed {
-                phase: "tick_end".into(),
-                error: "replace".into(),
-                exc_type: "OSError".into(),
-            },
-            "runtime.state.save_failed",
-        ),
-    ];
-    for (evt, want_tag) in &cases {
-        let json = serde_json::to_value(evt).unwrap();
-        assert_eq!(json["event"], *want_tag, "tag mismatch for {want_tag}");
-    }
-}
-
-#[test]
-fn tick_error_event_carries_exact_python_fields() {
-    // __main__.py:69-74 — error / exc_type / consecutive_failures / next_sleep_sec.
-    let evt = CoordinatorEvent::TickError {
-        error: "os.replace failed".into(),
-        exc_type: "OSError".into(),
-        consecutive_failures: 4,
-        next_sleep_sec: 40.0,
-    };
-    let json = serde_json::to_value(&evt).unwrap();
-    assert_eq!(json["event"], "coordinator.tick_error");
-    assert_eq!(json["error"], "os.replace failed");
-    assert_eq!(json["exc_type"], "OSError");
-    assert_eq!(json["consecutive_failures"], 4);
-    assert_eq!(json["next_sleep_sec"], 40.0);
-}
-
-#[test]
-fn unknown_persistent_event_provider_none_is_null_not_missing() {
-    // lifecycle.py:407 rollout_path=node.get(...) — None 漏穿堵死(bug-085):
-    // provider/rollout_path 缺失序列化为 JSON null,绝不省略键。
-    let evt = CoordinatorEvent::IdleTakeoverUnknownPersistent {
-        node_id: "w7".into(),
-        provider: None,
-        auth_mode: None,
-        consecutive_ticks: 72,
-        rollout_path: None,
-    };
-    let json = serde_json::to_value(&evt).unwrap();
-    assert_eq!(json["event"], "idle_takeover.unknown_persistent");
-    assert_eq!(json["node_id"], "w7");
-    assert!(
-        json.get("provider").is_some(),
-        "provider key MUST be present (None→null)"
-    );
-    assert!(json["provider"].is_null(), "provider None → JSON null");
-    assert!(
-        json.get("auth_mode").is_some(),
-        "auth_mode key MUST be present"
-    );
-    assert!(json["auth_mode"].is_null(), "auth_mode None → JSON null");
-    assert!(
-        json.get("rollout_path").is_some(),
-        "rollout_path key MUST be present"
-    );
-    assert!(json["rollout_path"].is_null());
-    assert_eq!(json["consecutive_ticks"], 72);
-}
-
 #[test]
 fn coordinator_metadata_json_field_names_are_stable() {
     // metadata.py:50-57 — 稳定 coordinator.json 契约。

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

@@ -25,23 +25,15 @@ fn meta(pid: u32, proto: u32, schema: i64) -> CoordinatorMetadata {
     }
 }
 
-/// `ProviderRegistry` mock — 断言**零** provider-client 调用 (MUST-NOT-13 / §84).
-/// `adapter_for`/`error_lists` 各记一次调用计数;abnormal-track 只允许触碰 `error_lists`,
-/// 绝不触碰 `adapter_for`(那会走真实 provider client crate)。
+/// `ProviderRegistry` mock — 记录 provider-client adapter 调用 (MUST-NOT-13 / §84).
 struct MockRegistry {
-    whitelist: Vec<String>,
-    blacklist: Vec<String>,
     adapter_calls: std::cell::Cell<u32>,
-    error_list_calls: std::cell::Cell<u32>,
 }
 
 impl MockRegistry {
-    fn new(whitelist: &[&str], blacklist: &[&str]) -> Self {
+    fn new(_whitelist: &[&str], _blacklist: &[&str]) -> Self {
         Self {
-            whitelist: whitelist.iter().map(|s| s.to_string()).collect(),
-            blacklist: blacklist.iter().map(|s| s.to_string()).collect(),
             adapter_calls: std::cell::Cell::new(0),
-            error_list_calls: std::cell::Cell::new(0),
         }
     }
 }
@@ -52,13 +44,6 @@ impl ProviderRegistry for MockRegistry {
         self.adapter_calls.set(self.adapter_calls.get() + 1);
         crate::provider::get_adapter(_provider)
     }
-    fn error_lists(&self, _provider: Provider) -> ErrorLists {
-        self.error_list_calls.set(self.error_list_calls.get() + 1);
-        ErrorLists {
-            whitelist: self.whitelist.clone(),
-            blacklist: self.blacklist.clone(),
-        }
-    }
 }
 
 /// in-memory `MarkerStore` —— durable marker 落盘探针。

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

@@ -260,45 +260,3 @@ fn p2_render_result_received_truncates_summary_to_80_chars() {
         "summary must be truncated to 80 chars"
     );
 }
-
-// P1 — idle_takeover.unknown_persistent must carry the auth_mode field (null when absent)
-// (lifecycle.py:401-408). NOTE: the variant currently lacks the field; the porter adds
-// `auth_mode` between provider and consecutive_ticks and updates this construction.
-#[test]
-fn p2_unknown_persistent_event_serializes_auth_mode_key() {
-    let evt = CoordinatorEvent::IdleTakeoverUnknownPersistent {
-        node_id: "w7".into(),
-        provider: None,
-        auth_mode: None,
-        consecutive_ticks: 72,
-        rollout_path: None,
-    };
-    let json = serde_json::to_value(&evt).unwrap();
-    assert!(
-        json.get("auth_mode").is_some(),
-        "idle_takeover.unknown_persistent must serialize an auth_mode key (null when absent)"
-    );
-}
-
-// P1 — process_abnormal_records matches a LOWERCASED signature too (abnormal_track.py:49,198):
-// raw has no needle but signature 'TimeoutError' matches blacklist 'timeout'. Current is
-// case-sensitive on `raw` only and ignores the signature → NotifyDefault.
-#[test]
-fn p2_abnormal_matches_lowercased_signature_too() {
-    let reg = MockRegistry::new(&[], &["timeout"]);
-    let records =
-        vec![serde_json::json!({"raw":"nothing here","signature":"TimeoutError","kind":"error"})];
-    let out = process_abnormal_records(
-        &records,
-        &reg,
-        Provider::Codex,
-        &AbnormalNotificationState::default(),
-    )
-    .unwrap();
-    assert_eq!(out.notifications.len(), 1);
-    assert_eq!(
-        out.notifications[0].decision,
-        AbnormalDecision::NotifyBlacklist,
-        "blacklist 'timeout' must match the lowercased signature 'TimeoutError'"
-    );
-}

package/crates/team-agent/src/coordinator/tick.rs

@@ -1,3 +1,4 @@
+//!
 //! Coordinator core:daemon lifecycle 宿主 + 单次 tick 编排(19 步固定顺序)+ health/start/stop。
 
 use std::collections::BTreeMap;
@@ -19,6 +20,7 @@ use super::health::{
     pid_is_running, read_coordinator_metadata, write_coordinator_metadata,
 };
 use super::runtime_observation::{self, CapturedRuntimeFact};
+use super::steps::TickStepGroup;
 use super::types::{
     AgentId, CoordinatorHealthStatus, HealthReport, MetadataSource, Pid, ProviderRegistry,
     SchemaHealth, StartError, StartOutcome, StartReport, StopError, StopOutcome, StopReport,
@@ -225,7 +227,7 @@ impl Coordinator {
     /// `if let Some(rec) = &self.order_recorder { rec.lock()...push(STEP_NAME) }`(tick
     /// 副作用 ORDER 测试断言固定序列)。生产两者均 `None`,零开销。
     pub fn tick(&self) -> Result<TickReport, TickError> {
-        self.record_step("load_state");
+        self.record_step(TickStepGroup::SessionGate, "load_state");
         let raw_state = crate::state::persist::load_runtime_state(self.workspace.as_path())?;
         // Issue 2 (Round 3b gate review §6): when the runtime carries
         // `active_team_key` AND `teams.<key>` exists, project the team-scoped
@@ -246,7 +248,7 @@ impl Coordinator {
         let event_log = EventLog::new(self.workspace.as_path());
         increment_coordinator_tick_iteration_count(&self.workspace);
 
-        self.record_step("tmux_session_gate");
+        self.record_step(TickStepGroup::SessionGate, "tmux_session_gate");
         if let Some(session_name) = state
             .get("session_name")
             .and_then(Value::as_str)
@@ -268,7 +270,7 @@ impl Coordinator {
             }
         }
 
-        self.record_step("capture_missing");
+        self.record_step(TickStepGroup::SessionGate, "capture_missing");
         let pending_context_fork_audits =
             match self.capture_missing_sessions(&mut state, &event_log) {
                 Ok(audits) => audits,
@@ -293,10 +295,10 @@ impl Coordinator {
             .unwrap_or_default();
         let has_work_obligation = tick_has_work_obligation(&store);
 
-        self.record_step("refresh_statuses");
+        self.record_step(TickStepGroup::HealthSync, "refresh_statuses");
         // TODO(spine slice 2b): split lightweight runtime status refresh from health sync.
 
-        self.record_step("startup_prompts");
+        self.record_step(TickStepGroup::RuntimePrompts, "startup_prompts");
         self.handle_startup_prompts(&mut state, &event_log, &pane_snapshot, &window_snapshot);
 
         // #229 step2-retry: once an agent's `startup_prompts` flipped to `handled`
@@ -318,7 +320,7 @@ impl Coordinator {
         // 否则 deliver_pending(下行投递主干)够不到,消息卡 accepted。
         // bug-084 哲学 + A-6 同族:每步独立 try,失败写 `coordinator.tick.<step>_failed`
         // 事件后继续走下一步;tick 本身仍返 Ok。
-        self.record_step("runtime_prompts");
+        self.record_step(TickStepGroup::RuntimePrompts, "runtime_prompts");
         if let Err(error) = self.handle_runtime_approval_prompts(
             &mut state,
             &event_log,
@@ -331,7 +333,7 @@ impl Coordinator {
             );
         }
 
-        self.record_step("sync_health");
+        self.record_step(TickStepGroup::HealthSync, "sync_health");
         // P5 (C-P5-1, N3): ONE pane snapshot per tick, shared by sync_health and the
         // abnormal-exit pass (same-tick reuse only — the snapshot does not outlive
         // this tick; every tick re-reads).
@@ -365,7 +367,7 @@ impl Coordinator {
             );
         }
 
-        self.record_step("deliver_pending");
+        self.record_step(TickStepGroup::Delivery, "deliver_pending");
         let delivered = crate::messaging::deliver_pending_messages(
             self.workspace.as_path(),
             &state,
@@ -376,7 +378,7 @@ impl Coordinator {
         .map(|message_id| DeliveredMessage { message_id })
         .collect::<Vec<_>>();
 
-        self.record_step("fire_scheduled");
+        self.record_step(TickStepGroup::Delivery, "fire_scheduled");
         let scheduled = crate::messaging::fire_due_scheduled_events(
             self.workspace.as_path(),
             &store,
@@ -394,18 +396,18 @@ impl Coordinator {
         // (deliver_pending / fire_scheduled / collect_results) above and below this
         // block continue to flow unchanged. `_state` / `_store` here are intentionally
         // unused (the lookups they powered were nag inputs only).
-        self.record_step("detect_stuck");
+        self.record_step(TickStepGroup::Abnormal, "detect_stuck");
         let stuck: Vec<AgentId> = Vec::new();
-        self.record_step("record_unknown_idle");
-        self.record_step("evaluate_takeover");
+        self.record_step(TickStepGroup::Abnormal, "record_unknown_idle");
+        self.record_step(TickStepGroup::Abnormal, "evaluate_takeover");
         let idle_alerts: Vec<IdleAlert> = Vec::new();
-        self.record_step("detect_deadlocks");
+        self.record_step(TickStepGroup::Abnormal, "detect_deadlocks");
         let deadlock_alerts: Vec<DeadlockAlert> = Vec::new();
         let _ = &store;
 
-        self.record_step("detect_compaction");
-        self.record_step("detect_drift");
-        self.record_step("detect_api_errors");
+        self.record_step(TickStepGroup::Abnormal, "detect_compaction");
+        self.record_step(TickStepGroup::Abnormal, "detect_drift");
+        self.record_step(TickStepGroup::Abnormal, "detect_api_errors");
         let leader_capture = self.capture_leader_receiver(&state);
         let observations = runtime_observation::observe(
             self.workspace.as_path(),
@@ -425,7 +427,7 @@ impl Coordinator {
             results: Vec::new(),
         };
 
-        self.record_step("atomic_save");
+        self.record_step(TickStepGroup::Persist, "atomic_save");
         let saved = match &self.save_hook {
             Some(hook) => hook(&self.workspace, &state),
             None => {
@@ -474,20 +476,20 @@ impl Coordinator {
         // step, and drives the lifecycle helper. Runs OUTSIDE the pre-save
         // window so nested lifecycle saves cannot be clobbered by this
         // tick's final in-memory save (R6 boundary guard).
-        self.record_step("attempt_api_error_recoveries");
+        self.record_step(TickStepGroup::Abnormal, "attempt_api_error_recoveries");
         crate::coordinator::steps::abnormal::attempt_due_recoveries(
             self.workspace.as_path(),
             &event_log,
             self.transport.as_ref(),
         );
 
-        self.record_step("collect_results");
+        self.record_step(TickStepGroup::Delivery, "collect_results");
         collections.results =
             collect_results(crate::messaging::collect_results_and_notify_watchers(
                 self.workspace.as_path(),
                 &event_log,
             )?);
-        self.record_step("prune_dedupe_log");
+        self.record_step(TickStepGroup::Persist, "prune_dedupe_log");
         Ok(base_tick_report(true, false, None, Some(true), collections))
     }
 
@@ -1430,7 +1432,8 @@ impl Coordinator {
         super::health::message_store_schema_health(&self.workspace)
     }
 
-    fn record_step(&self, step: &'static str) {
+    fn record_step(&self, group: TickStepGroup, step: &'static str) {
+        debug_assert!(TickStepGroup::ordered().contains(&group));
         if let Some(recorder) = &self.order_recorder {
             if let Ok(mut guard) = recorder.lock() {
                 guard.push(step);
@@ -2757,13 +2760,6 @@ mod u1_tests {
                 ),
             )
         }
-
-        fn error_lists(
-            &self,
-            _provider: crate::provider::Provider,
-        ) -> super::super::types::ErrorLists {
-            super::super::types::ErrorLists::default()
-        }
     }
 
     #[test]