@team-agent/installer 0.3.4 → 0.3.5

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

@@ -17,7 +17,9 @@ use rusqlite::params;
         compact: bool,
         detail: bool,
     ) -> Result<Value, CliError> {
-        let _ = detail;
+        // commands.py:99 — `--json --detail` maps to compact=False: detail wins and
+        // returns the FULL payload.
+        let compact = compact && !detail;
         let resolved_owner_team_id = resolve_status_owner_team(workspace, owner_team_id)?;
         let owner_team_id = resolved_owner_team_id.as_deref().or(owner_team_id);
         let health = crate::coordinator::coordinator_health(
@@ -63,7 +65,7 @@ use rusqlite::params;
             "messages": message_counts(&conn, owner_team_id)?,
             "queued_messages": queued_messages(&conn, owner_team_id, 8)?,
             "results": result_counts(&conn, owner_team_id)?,
-            "latest_results": json!([]),
+            "latest_results": latest_result_summaries(&store, owner_team_id)?,
             "readiness": readiness,
             "coordinator": coordinator_health_value(health),
             "last_events": Value::Array(
@@ -90,11 +92,137 @@ use rusqlite::params;
         owner_team_id: Option<&str>,
         agent: Option<&str>,
     ) -> Result<String, CliError> {
-        let status = status_scoped(workspace, state, owner_team_id, true, false)?;
-        Ok(match agent {
-            Some(agent) => format!("agent {agent}: {}", status.pointer("/agents").is_some()),
-            None => crate::cli::format_status_summary(&status),
-        })
+        match agent {
+            // queries.py:130-162 — the agent branch renders the multi-line agent detail
+            // from the FULL status payload; an unknown agent id errors.
+            Some(agent) => {
+                let status = status_scoped(workspace, state, owner_team_id, false, false)?;
+                format_agent_status(workspace, &status, agent)
+            }
+            None => {
+                let status = status_scoped(workspace, state, owner_team_id, true, false)?;
+                Ok(crate::cli::format_status_summary(&status))
+            }
+        }
+    }
+
+    /// `format_status` agent 分支(`queries.py:135-162`)。
+    fn format_agent_status(
+        workspace: &Path,
+        status: &Value,
+        agent_id: &str,
+    ) -> Result<String, CliError> {
+        let agents = status.get("agents").and_then(Value::as_object);
+        let health = status.get("agent_health").and_then(Value::as_object);
+        let known = agents.is_some_and(|map| map.contains_key(agent_id))
+            || health.is_some_and(|map| map.contains_key(agent_id));
+        if !known {
+            return Err(CliError::Runtime(format!("unknown agent id: {agent_id}")));
+        }
+        let empty = json!({});
+        let agent = agents
+            .and_then(|map| map.get(agent_id))
+            .unwrap_or(&empty);
+        let row = health.and_then(|map| map.get(agent_id)).unwrap_or(&empty);
+        let status_text = row
+            .get("status")
+            .and_then(Value::as_str)
+            .map(str::to_string)
+            .unwrap_or_else(||
+
+                agent_health_status_text(agent.get("status").and_then(Value::as_str).unwrap_or(""))
+            );
+        let tasks = status.get("tasks").and_then(Value::as_array).cloned().unwrap_or_default();
+        let task_id = current_task_for_agent(&tasks, agent_id).unwrap_or_else(|| "-".to_string());
+        let inbox_rows = crate::message_store::MessageStore::open(workspace)
+            .map_err(|e| CliError::Runtime(e.to_string()))?
+            .inbox(agent_id, 3, None)
+            .map_err(|e| CliError::Runtime(e.to_string()))?;
+        let mut lines = vec![
+            format!("{agent_id}  {status_text}"),
+            format!("  provider: {}", py_get(agent, "provider")),
+            format!("  model: {}", py_get(agent, "model")),
+            format!("  profile: {}", py_get(agent, "profile")),
+            format!("  session_id: {}", py_get_or_dash(agent, "session_id")),
+            format!("  captured_via: {}", py_get_or_dash(agent, "captured_via")),
+            format!(
+                "  attribution_confidence: {}",
+                py_get_or_dash(agent, "attribution_confidence")
+            ),
+            format!("  task: {task_id}"),
+            format!("  handoff: {}", py_get(agent, "handoff_path")),
+            "  recent messages:".to_string(),
+        ];
+        if inbox_rows.is_empty() {
+            lines.push("    none".to_string());
+        } else {
+            for item in &inbox_rows {
+                let content = item.get("content").and_then(Value::as_str).unwrap_or("");
+                let content: String = content.chars().take(120).collect();
+                lines.push(format!(
+                    "    {} {} -> {} {}: {content}",
+                    py_get_or_dash(item, "created_at"),
+                    py_get_or_dash(item, "sender"),
+                    py_get_or_dash(item, "recipient"),
+                    py_get_or_dash(item, "status"),
+                ));
+            }
+        }
+        Ok(lines.join("\n"))
+    }
+
+    /// `current_task_for_agent`(`approvals/status.py:127-132`)。
+    fn current_task_for_agent(tasks: &[Value], agent_id: &str) -> Option<String> {
+        const ACTIVE: [&str; 5] = ["pending", "ready", "running", "blocked", "needs_retry"];
+        for task in tasks.iter().rev() {
+            let assignee = task.get("assignee").and_then(Value::as_str);
+            let status = task.get("status").and_then(Value::as_str).unwrap_or("pending");
+            if assignee == Some(agent_id) && ACTIVE.contains(&status) {
+                return task.get("id").and_then(Value::as_str).map(str::to_string);
+            }
+        }
+        None
+    }
+
+    fn agent_health_status_text(status: &str) -> String {
+        serde_json::to_value(crate::provider::agent_health_status(status))
+            .ok()
+            .and_then(|v| v.as_str().map(str::to_string))
+            .unwrap_or_else(|| "-".to_string())
+    }
+
+    /// Python `agent.get(key, '-')`:键缺失 → `-`;键存在但为 null → 打印 `None`。
+    fn py_get(agent: &Value, key: &str) -> String {
+        match agent.get(key) {
+            None => "-".to_string(),
+            Some(Value::Null) => "None".to_string(),
+            Some(Value::String(s)) => s.clone(),
+            Some(other) => other.to_string(),
+        }
+    }
+
+    /// Python `agent.get(key) or '-'`:缺失/null/空串都落 `-`。
+    fn py_get_or_dash(agent: &Value, key: &str) -> String {
+        match agent.get(key) {
+            Some(Value::String(s)) if !s.is_empty() => s.clone(),
+            Some(Value::Number(n)) => n.to_string(),
+            _ => "-".to_string(),
+        }
+    }
+
+    /// `latest_result_summaries`(`queries.py:83-89`)。
+    fn latest_result_summaries(
+        store: &crate::message_store::MessageStore,
+        owner_team_id: Option<&str>,
+    ) -> Result<Value, CliError> {
+        let rows = store
+            .latest_results(5, owner_team_id)
+            .map_err(|e| CliError::Runtime(e.to_string()))?;
+        Ok(Value::Array(
+            rows.iter()
+                .filter_map(crate::message_store::result_summary_from_row)
+                .collect(),
+        ))
     }
     /// `status.approvals(workspace, agent_id)`(JSON)/`format_approvals`(人读)。
     pub fn approvals(workspace: &Path, agent: Option<&str>, as_json: bool) -> Result<Value, CliError> {

package/crates/team-agent/src/cli/tests/missing_subcommands.rs

@@ -320,7 +320,12 @@ tasks:
     // hinges solely on the cli_prompt_ready derivation.)
     #[test]
     fn contract_alive_worker_running_is_cli_prompt_ready_and_ready() {
-        let state = serde_json::json!({"agents": {"w1": {
+        // A-5: missing leader_receiver no longer counts as attached; this contract's
+        // subject is the cli_prompt_ready derivation, so the fixture carries an
+        // attached receiver to keep `ready` hinging on it alone.
+        let state = serde_json::json!({
+            "leader_receiver": {"status": "attached", "pane_id": "%9"},
+            "agents": {"w1": {
             "status": "running",
             "pane_id": "%1",
             "mcp_ready": true,
@@ -361,6 +366,8 @@ tasks:
         let state = serde_json::json!({
             "session_name": "ta-fake",
             "tmux_session_present": true, // golden status() top-level signal: the live tmux session exists
+            // A-5: missing leader_receiver no longer counts as attached (see above).
+            "leader_receiver": {"status": "attached", "pane_id": "%9"},
             "agents": { "w1": {
                 "status": "running",
                 "mcp_config": mcp.to_string_lossy(),

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

@@ -95,3 +95,4 @@ mod verb_validate;
 mod verb_settle;
 mod verb_profile;
 mod main_preserved;
+mod shutdown_kill_plan;

package/crates/team-agent/src/cli/tests/shutdown_kill_plan.rs

@@ -0,0 +1,39 @@
+//! B5/F1 · `sessions_to_kill_sparing_leader` 纯函数单测(kill 决策下沉后锁定)。
+//!
+//! 真相源 = `team-agent-leader-` 确定性命名前缀(leader/start.rs LEADER_SESSION_PREFIX);
+//! 集成面由 tests/b5_leader_terminal_kill_red.rs 的真 tmux 契约覆盖,此处锁纯决策。
+
+use crate::cli::lifecycle_port::sessions_to_kill_sparing_leader;
+use crate::transport::SessionName;
+
+fn names(raw: &[&str]) -> Vec<SessionName> {
+    raw.iter().map(|name| SessionName::new(*name)).collect()
+}
+
+#[test]
+fn no_leader_session_means_whole_server_kill() {
+    assert_eq!(sessions_to_kill_sparing_leader(&names(&["team-x"])), None);
+    assert_eq!(sessions_to_kill_sparing_leader(&[]), None);
+}
+
+#[test]
+fn leader_session_present_kills_only_non_leader_sessions() {
+    let sessions = names(&[
+        "team-agent-leader-claude-myws-deadbeef",
+        "team-x",
+        "team-y",
+    ]);
+    let to_kill = sessions_to_kill_sparing_leader(&sessions)
+        .expect("leader present must switch to per-session kills");
+    assert_eq!(to_kill, names(&["team-x", "team-y"]));
+}
+
+#[test]
+fn only_leader_sessions_left_kills_nothing_but_keeps_server() {
+    let sessions = names(&["team-agent-leader-codex-myws-cafe0123"]);
+    assert_eq!(
+        sessions_to_kill_sparing_leader(&sessions),
+        Some(Vec::new()),
+        "a socket holding only leader sessions must not be torn down"
+    );
+}

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

@@ -513,10 +513,14 @@ pub struct DoctorArgs {
 }
 
 /// `doctor --gate` 选择(`commands.py:218-236`;clap choices)。
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+/// swallow batch 3: an unrecognized gate is carried verbatim so the doctor exit can
+/// refuse with `unknown_gate` (Python commands.py:234-235 raises) instead of silently
+/// falling through to the default doctor (empty green).
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum DoctorGate {
     Orphans,
     Comms,
+    Unknown(String),
 }
 
 /// `sessions`(`parser.py:230`)。

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

@@ -68,8 +68,25 @@ pub fn run_daemon_with_coordinator(
         Some(v) if v > 0.0 => v,
         _ => resolve_tick_interval(&args.workspace)?,
     };
+    // P7 (Gap 37b, Python __main__.py:44-59): capture the original parent BEFORE the
+    // loop; the orphan predicate fires only on the literal triple condition
+    // (ppid changed ∧ reparented to pid 1 ∧ workspace gone) — never wider.
+    let initial_ppid = current_ppid();
     let mut consecutive_failures = 0_u32;
+    let mut last_failure_signature: Option<String> = None;
     loop {
+        let ppid_now = current_ppid();
+        if super::should_orphan_self_terminate(initial_ppid, ppid_now, &args.workspace) {
+            let _ = event_log.write(
+                "coordinator.orphan_self_terminate",
+                serde_json::json!({
+                    "initial_ppid": initial_ppid,
+                    "current_ppid": ppid_now,
+                    "workspace": args.workspace.as_path().to_string_lossy(),
+                }),
+            );
+            break;
+        }
         match coordinator.tick() {
             Ok(report) => {
                 if consecutive_failures > 0 {
@@ -78,6 +95,7 @@ pub fn run_daemon_with_coordinator(
                         serde_json::json!({"consecutive_failures": consecutive_failures}),
                     )?;
                     consecutive_failures = 0;
+                    last_failure_signature = None;
                 }
                 if report.stop || args.once {
                     break;
@@ -87,15 +105,40 @@ pub fn run_daemon_with_coordinator(
             Err(err) => {
                 consecutive_failures = consecutive_failures.saturating_add(1);
                 let next_sleep_sec = backoff_sleep_sec(tick_interval, consecutive_failures);
-                event_log.write(
-                    "coordinator.tick_error",
-                    serde_json::json!({
-                        "error": err.to_string(),
-                        "exc_type": "TickError",
-                        "consecutive_failures": consecutive_failures,
-                        "next_sleep_sec": next_sleep_sec,
-                    }),
-                )?;
+                // P7-F2 (Python __main__.py:66-89): identical-signature failures emit
+                // ONE full tick_error; repeats only write `.suppressed` companions,
+                // except the Python periodic re-emit tiers (failure #1, every 12th
+                // failure, or the 40s/60s backoff steps).
+                let signature: String = err.to_string().chars().take(200).collect();
+                let signature_changed =
+                    last_failure_signature.as_deref() != Some(signature.as_str());
+                if signature_changed {
+                    last_failure_signature = Some(signature);
+                }
+                if signature_changed
+                    || consecutive_failures == 1
+                    || consecutive_failures % 12 == 0
+                    || next_sleep_sec == 40.0
+                    || next_sleep_sec == 60.0
+                {
+                    event_log.write(
+                        "coordinator.tick_error",
+                        serde_json::json!({
+                            "error": err.to_string(),
+                            "exc_type": "TickError",
+                            "consecutive_failures": consecutive_failures,
+                            "next_sleep_sec": next_sleep_sec,
+                        }),
+                    )?;
+                } else {
+                    event_log.write(
+                        "coordinator.tick_error.suppressed",
+                        serde_json::json!({
+                            "consecutive_failures": consecutive_failures,
+                            "next_sleep_sec": next_sleep_sec,
+                        }),
+                    )?;
+                }
                 if args.once {
                     return Err(DaemonError::Tick(err));
                 }
@@ -107,6 +150,11 @@ pub fn run_daemon_with_coordinator(
     Ok(())
 }
 
+/// 当前 ppid(`os.getppid()`,孤儿自检输入)。
+fn current_ppid() -> u32 {
+    u32::try_from(unsafe { libc::getppid() }).unwrap_or(0)
+}
+
 /// 计算 tick 间隔(`_tick_interval`,`__main__.py:104-115`)。读 spec `runtime.tick_interval_sec`,
 /// 缺失/出错 → `DEFAULT_TICK_INTERVAL_SEC`;并确保 schema 存在(`MessageStore(workspace)`)。
 pub fn resolve_tick_interval(workspace: &WorkspacePath) -> Result<f64, TickError> {

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

@@ -425,7 +425,7 @@ pub fn write_coordinator_metadata(
     std::fs::write(path, text)
 }
 
-fn message_store_schema_health(workspace: &WorkspacePath) -> SchemaHealth {
+pub(crate) fn message_store_schema_health(workspace: &WorkspacePath) -> SchemaHealth {
     match MessageStore::open(workspace.as_path()) {
         Ok(_) => SchemaHealth {
             ok: true,
@@ -490,7 +490,17 @@ pub fn collect_watch_lines(
     store: &MessageStore,
     team: Option<&str>,
 ) -> Result<Vec<String>, WatchError> {
-    let _ = (store, team);
+    let mut lines = collect_event_lines(workspace, cursor, team)?;
+    lines.extend(collect_result_lines(workspace, cursor, store, team)?);
+    Ok(lines)
+}
+
+/// `_collect_event_lines`(`watch.py:66-97`):tail events.jsonl,按 team 过滤。
+fn collect_event_lines(
+    workspace: &WorkspacePath,
+    cursor: &mut WatchCursor,
+    team: Option<&str>,
+) -> Result<Vec<String>, WatchError> {
     let logs = crate::model::paths::logs_dir(workspace.as_path());
     let events_path = logs.join("events.jsonl");
     let archive_path = logs.join("events.jsonl.1");
@@ -521,6 +531,10 @@ pub fn collect_watch_lines(
     cursor.initialized = true;
     for line in text.lines() {
         if let Ok(event) = serde_json::from_str::<Value>(line) {
+            // watch.py:91 — `if team and _event_team_id(event) != team: continue`.
+            if team.is_some() && event_team_id(&event).as_deref() != team {
+                continue;
+            }
             if let Some(rendered) = render_event_line(&event) {
                 lines.push(rendered);
             }
@@ -529,6 +543,55 @@ pub fn collect_watch_lines(
     Ok(lines)
 }
 
+/// `_event_team_id`(`watch.py:132-134`)。
+fn event_team_id(event: &Value) -> Option<String> {
+    ["team_id", "owner_team_id", "team"]
+        .iter()
+        .find_map(|key| event.get(*key))
+        .and_then(|value| match value {
+            Value::String(s) if !s.is_empty() => Some(s.clone()),
+            Value::Number(n) => Some(n.to_string()),
+            _ => None,
+        })
+}
+
+/// `_collect_result_lines`(`watch.py:100-112`):store.latest_results(owner_team_id=team)
+/// 出 `result_received: {agent} -> {summary}` 行;按 cursor.seen_result_ids 去重。
+fn collect_result_lines(
+    workspace: &WorkspacePath,
+    cursor: &mut WatchCursor,
+    store: &MessageStore,
+    team: Option<&str>,
+) -> Result<Vec<String>, WatchError> {
+    let db_path = crate::model::paths::runtime_dir(workspace.as_path()).join("team.db");
+    if !db_path.exists() {
+        return Ok(Vec::new());
+    }
+    let mut lines = Vec::new();
+    for row in store.latest_results(20, team)? {
+        let Some(result_id) = row
+            .get("result_id")
+            .and_then(Value::as_str)
+            .filter(|id| !id.is_empty())
+            .map(str::to_string)
+        else {
+            continue;
+        };
+        if !cursor.seen_result_ids.insert(result_id) {
+            continue;
+        }
+        let mut summary = crate::message_store::result_summary_from_row(&row)
+            .unwrap_or_else(|| serde_json::json!({}));
+        if let Some(obj) = summary.as_object_mut() {
+            obj.insert("event".to_string(), Value::String("result_received".to_string()));
+        }
+        if let Some(rendered) = render_event_line(&summary) {
+            lines.push(rendered);
+        }
+    }
+    Ok(lines)
+}
+
 /// `render_event_line`(`watch.py:46-63`)。把一条 step 4 事件渲染成人类可读行;非可渲染事件 → `None`。
 /// 消费的事件类型:`result_received` / `leader_receiver.{injected,submitted}` / `send.failed` /
 /// `leader_receiver.rebind_required` / `leader.api_error`(card 表)。

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

@@ -54,18 +54,23 @@ fn detect_compaction(
         .as_ref()
         .map(|team| team.as_str().to_string())
         .unwrap_or_else(|| crate::state::projection::team_state_key(state));
-    let current = update_compaction_count(state, &team, &fact.agent_id, count);
+    let (previous, current) = update_compaction_count(state, &team, &fact.agent_id, count);
     let provider = fact.provider;
-    let _ = event_log.write(
-        "coordinator.compaction_observed",
-        json!({
-            "agent_id": fact.agent_id.as_str(),
-            "provider": provider.map(provider_name),
-            "team": team,
-            "compaction_count": current,
-            "stuck_loop": false,
-        }),
-    );
+    // P4 (C-P4-1, N35 anti-nag): the event is CHANGE-driven — an unchanged compaction
+    // count must not re-emit every tick (live sample: 1037 identical events / 19.5min).
+    // A changed value still emits (value-keyed dedup, not blanket suppression).
+    if current != previous {
+        let _ = event_log.write(
+            "coordinator.compaction_observed",
+            json!({
+                "agent_id": fact.agent_id.as_str(),
+                "provider": provider.map(provider_name),
+                "team": team,
+                "compaction_count": current,
+                "stuck_loop": false,
+            }),
+        );
+    }
     let threshold = compaction_reset_threshold(state);
     let recommendation = if provider == Some(Provider::Codex) && current >= threshold {
         let message = format!(
@@ -231,15 +236,21 @@ fn count_compaction_markers(scrollback: &str) -> i64 {
         + lower.matches("compaction occurred").count() as i64
 }
 
-fn update_compaction_count(state: &mut Value, team: &str, agent_id: &AgentId, count: i64) -> i64 {
+/// Returns `(previous, current)` so the caller can emit change-driven events (P4).
+fn update_compaction_count(
+    state: &mut Value,
+    team: &str,
+    agent_id: &AgentId,
+    count: i64,
+) -> (i64, i64) {
     let Some(coordinator) = coordinator_object_mut(state) else {
-        return count;
+        return (0, count);
     };
     let Some(counts) = object_field_mut(coordinator, "compaction_counts") else {
-        return count;
+        return (0, count);
     };
     let Some(team_counts) = object_field_mut(counts, team) else {
-        return count;
+        return (0, count);
     };
     let previous = team_counts
         .get(agent_id.as_str())
@@ -247,7 +258,7 @@ fn update_compaction_count(state: &mut Value, team: &str, agent_id: &AgentId, co
         .unwrap_or(0);
     let current = previous.max(count);
     team_counts.insert(agent_id.as_str().to_string(), json!(current));
-    current
+    (previous, current)
 }
 
 fn compaction_reset_threshold(state: &Value) -> i64 {
@@ -448,6 +459,7 @@ fn provider_name(provider: Provider) -> &'static str {
         Provider::Claude => "claude",
         Provider::ClaudeCode => "claude_code",
         Provider::Codex => "codex",
+        Provider::Copilot => "copilot",
         Provider::GeminiCli => "gemini_cli",
         Provider::Fake => "fake",
     }

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

@@ -0,0 +1,87 @@
+use super::*;
+
+// ═════════════════════════════════════════════════════════════════════════
+// A0 GREEN regression lock, 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).
+//
+// 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
+// AFTER tick's load and BEFORE tick's save, then delegate to the real
+// `save_team_scoped_state`. Zero sleeps, zero real races — ordering is fixed by the
+// hook call order.
+// ═════════════════════════════════════════════════════════════════════════
+
+#[test]
+fn a0_green_lock_tick_save_preserves_registration_landed_after_tick_load() {
+    let dir = std::env::temp_dir().join(format!(
+        "team-agent-coord-a0-{}-{}",
+        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();
+
+    // The hook runs at tick's atomic-save point: first simulate the concurrent
+    // add-agent registration landing on disk (raw write, as another process would),
+    // then run the REAL save path with tick's stale in-memory state.
+    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"]["joiner"] = serde_json::json!({
+            "provider": "codex", "status": "running", "agent_id": "joiner", "window": "joiner",
+        });
+        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, "tick must not degrade; 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();
+    assert!(
+        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}"
+    );
+    // 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
+    // counter-free BY DESIGN (p3_steady_tick_no_state_write). The original proxy
+    // ("tick's save really happened") is preserved via the counter metadata file.
+    let tick_meta: serde_json::Value = serde_json::from_str(
+        &std::fs::read_to_string(dir.join(".team/runtime/coordinator_tick.json")).unwrap(),
+    )
+    .unwrap();
+    assert!(
+        tick_meta
+            .get("coordinator_tick_iteration_count")
+            .and_then(serde_json::Value::as_u64)
+            .is_some_and(|count| count >= 1),
+        "the tick really ran (its iteration counter metadata landed); tick_meta={tick_meta}"
+    );
+}

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

@@ -308,3 +308,4 @@ mod health_sync;
 mod takeover;
 mod daemon;
 mod main_preserved;
+mod a0_lostupdate;