@team-agent/installer 0.4.10 → 0.5.0

package/crates/team-agent/src/messaging/activity.rs

@@ -59,7 +59,10 @@ pub fn detect_idle_fallbacks(
     let idle_workers = stmt
         .query_map(params![team.as_str()], |row| row.get::<_, String>(0))?
         .collect::<Result<Vec<_>, _>>()?;
-    let worker_set = workers.iter().cloned().collect::<std::collections::BTreeSet<_>>();
+    let worker_set = workers
+        .iter()
+        .cloned()
+        .collect::<std::collections::BTreeSet<_>>();
     let idle_set = idle_workers
         .iter()
         .cloned()
@@ -74,8 +77,16 @@ pub fn detect_idle_fallbacks(
     }
     let now = chrono::Utc::now().to_rfc3339();
     let mut next_state = state.clone();
-    register_idle_fallback_suppression(&mut next_state, store, &team, &idle_workers, &now)?;
-    crate::state::persist::save_runtime_state(workspace, &next_state)?;
+    let suppression_snapshots =
+        idle_fallback_suppression_snapshots(&next_state, store, &team, &idle_workers)?;
+    register_idle_fallback_suppression(&mut next_state, &team, &now, &suppression_snapshots);
+    crate::state::persist::save_runtime_state_reapplying_after_conflict(
+        workspace,
+        &next_state,
+        |latest| {
+            register_idle_fallback_suppression(latest, &team, &now, &suppression_snapshots);
+        },
+    )?;
     let alert_count = idle_workers.len();
     let content = format!(
         "Idle fallback: all workers idle while {obligation_count} undelivered obligation(s) remain."
@@ -213,7 +224,11 @@ fn active_team_key(workspace: &Path, state: &Value) -> String {
         .and_then(Value::as_str)
         .filter(|team| !team.is_empty())
         .map(ToString::to_string)
-        .or_else(|| workspace.file_name().map(|name| name.to_string_lossy().to_string()))
+        .or_else(|| {
+            workspace
+                .file_name()
+                .map(|name| name.to_string_lossy().to_string())
+        })
         .unwrap_or_else(|| "current".to_string())
 }
 
@@ -298,14 +313,13 @@ fn idle_fallback_suppressed(
         && delivered == delivered_message_ids(store, team, agent_id)?)
 }
 
-fn register_idle_fallback_suppression(
-    state: &mut Value,
+fn idle_fallback_suppression_snapshots(
+    state: &Value,
     store: &MessageStore,
     team: &str,
     idle_workers: &[String],
-    now: &str,
-) -> Result<(), MessagingError> {
-    let snapshots = idle_workers
+) -> Result<Vec<(String, Vec<String>, Vec<String>)>, MessagingError> {
+    idle_workers
         .iter()
         .map(|agent_id| {
             Ok((
@@ -314,23 +328,31 @@ fn register_idle_fallback_suppression(
                 delivered_message_ids(store, team, agent_id)?,
             ))
         })
-        .collect::<Result<Vec<_>, MessagingError>>()?;
+        .collect::<Result<Vec<_>, MessagingError>>()
+}
+
+fn register_idle_fallback_suppression(
+    state: &mut Value,
+    team: &str,
+    now: &str,
+    snapshots: &[(String, Vec<String>, Vec<String>)],
+) {
     let Some(root) = state.as_object_mut() else {
-        return Ok(());
+        return;
     };
     let Some(coordinator) = root
         .entry("coordinator")
         .or_insert_with(|| serde_json::json!({}))
         .as_object_mut()
     else {
-        return Ok(());
+        return;
     };
     let Some(last) = coordinator
         .entry("idle_fallback_last_fired_at")
         .or_insert_with(|| serde_json::json!({}))
         .as_object_mut()
     else {
-        return Ok(());
+        return;
     };
     last.insert(team.to_string(), serde_json::Value::String(now.to_string()));
     let Some(all) = coordinator
@@ -338,18 +360,18 @@ fn register_idle_fallback_suppression(
         .or_insert_with(|| serde_json::json!({}))
         .as_object_mut()
     else {
-        return Ok(());
+        return;
     };
     let Some(team_map) = all
         .entry(team.to_string())
         .or_insert_with(|| serde_json::json!({}))
         .as_object_mut()
     else {
-        return Ok(());
+        return;
     };
     for (agent_id, assigned, delivered) in snapshots {
         let Some(agent_map) = team_map
-            .entry(agent_id)
+            .entry(agent_id.clone())
             .or_insert_with(|| serde_json::json!({}))
             .as_object_mut()
         else {
@@ -367,7 +389,6 @@ fn register_idle_fallback_suppression(
             }),
         );
     }
-    Ok(())
 }
 
 fn timestamp_in_future(ts: &str) -> bool {
@@ -407,7 +428,11 @@ fn assigned_task_ids(state: &Value, agent_id: &str) -> Vec<String> {
             tasks
                 .iter()
                 .filter(|task| task.get("assignee").and_then(Value::as_str) == Some(agent_id))
-                .filter_map(|task| task.get("id").and_then(Value::as_str).map(ToString::to_string))
+                .filter_map(|task| {
+                    task.get("id")
+                        .and_then(Value::as_str)
+                        .map(ToString::to_string)
+                })
                 .collect::<Vec<_>>()
         })
         .unwrap_or_default();

package/crates/team-agent/src/messaging/delivery.rs

@@ -9,6 +9,9 @@ use crate::event_log::EventLog;
 use crate::message_store::MessageStore;
 use crate::model::enums::{PaneLiveness, Provider};
 use crate::model::ids::TeamKey;
+use crate::provider::wire::{
+    is_claude_family, parse_canonical_provider, parse_provider, provider_wire,
+};
 use crate::transport::{
     submit_verification_wire, InjectPayload, InjectReport, InjectVerification, Key, PaneId,
     PaneInfo, SessionName, SubmitVerification, Target, Transport, WindowName,
@@ -302,76 +305,63 @@ pub fn deliver_pending_message(
     } else {
         InjectPayload::Text(rendered)
     };
-    let inject_report =
-        match transport.inject(&target, &payload, Key::Enter, true) {
-            Ok(report) => report,
-            Err(error) => {
-                let reason = format!("inject_failed:{error}");
-                if message.recipient == "leader" {
-                    store.mark(message_id, "failed", Some("leader_not_attached"))?;
-                    event_log.write(
-                        "leader_receiver.delivery_blocked",
-                        serde_json::json!({
-                            "message_id": message_id,
-                            "sender": message.sender,
-                            "reason": "leader_not_attached",
-                            "channel": "rebind_required",
-                            "action": "run team-agent claim-leader or team-agent takeover",
-                            "error": error.to_string(),
-                        }),
-                    )?;
-                    return Ok(DeliveryOutcome {
-                        ok: false,
-                        status: DeliveryStatus::Refused,
-                        message_status: MessageStatusShadow("failed".to_string()),
-                        message_id: Some(message_id.to_string()),
-                        verification: Some(
-                            "run team-agent claim-leader or team-agent takeover".to_string(),
-                        ),
-                        stage: None,
-                        reason: Some(DeliveryRefusal::LeaderNotAttached),
-                        channel: Some("rebind_required".to_string()),
-                    });
-                }
+    let inject_report = match transport.inject(&target, &payload, Key::Enter, true) {
+        Ok(report) => report,
+        Err(error) => {
+            let reason = format!("inject_failed:{error}");
+            if message.recipient == "leader" {
+                store.mark(message_id, "failed", Some("leader_not_attached"))?;
                 event_log.write(
-                    "send.inject_failed",
+                    "leader_receiver.delivery_blocked",
                     serde_json::json!({
                         "message_id": message_id,
-                        "recipient": message.recipient,
-                        "attempts": attempt,
-                        "max_attempts": SEND_RETRY_MAX_ATTEMPTS,
+                        "sender": message.sender,
+                        "reason": "leader_not_attached",
+                        "channel": "rebind_required",
+                        "action": "run team-agent claim-leader or team-agent takeover",
                         "error": error.to_string(),
                     }),
                 )?;
-                if attempt >= u32::from(SEND_RETRY_MAX_ATTEMPTS) {
-                    store.mark(message_id, "failed", Some("send_inject_exhausted"))?;
-                    emit_send_failed_exhausted(
-                        workspace,
-                        state,
-                        event_log,
-                        message_id,
-                        &message.recipient,
-                        attempt,
-                        "send_inject_exhausted",
-                        &reason,
-                        None,
-                    )?;
-                    return Ok(DeliveryOutcome {
-                        ok: false,
-                        status: DeliveryStatus::Failed,
-                        message_status: MessageStatusShadow("failed".to_string()),
-                        message_id: Some(message_id.to_string()),
-                        verification: Some(reason),
-                        stage: Some(DeliveryStage::Inject),
-                        reason: None,
-                        channel: None,
-                    });
-                }
-                store.mark(message_id, "target_resolved", Some(&reason))?;
                 return Ok(DeliveryOutcome {
                     ok: false,
-                    status: DeliveryStatus::Degraded,
-                    message_status: MessageStatusShadow("target_resolved".to_string()),
+                    status: DeliveryStatus::Refused,
+                    message_status: MessageStatusShadow("failed".to_string()),
+                    message_id: Some(message_id.to_string()),
+                    verification: Some(
+                        "run team-agent claim-leader or team-agent takeover".to_string(),
+                    ),
+                    stage: None,
+                    reason: Some(DeliveryRefusal::LeaderNotAttached),
+                    channel: Some("rebind_required".to_string()),
+                });
+            }
+            event_log.write(
+                "send.inject_failed",
+                serde_json::json!({
+                    "message_id": message_id,
+                    "recipient": message.recipient,
+                    "attempts": attempt,
+                    "max_attempts": SEND_RETRY_MAX_ATTEMPTS,
+                    "error": error.to_string(),
+                }),
+            )?;
+            if attempt >= u32::from(SEND_RETRY_MAX_ATTEMPTS) {
+                store.mark(message_id, "failed", Some("send_inject_exhausted"))?;
+                emit_send_failed_exhausted(
+                    workspace,
+                    state,
+                    event_log,
+                    message_id,
+                    &message.recipient,
+                    attempt,
+                    "send_inject_exhausted",
+                    &reason,
+                    None,
+                )?;
+                return Ok(DeliveryOutcome {
+                    ok: false,
+                    status: DeliveryStatus::Failed,
+                    message_status: MessageStatusShadow("failed".to_string()),
                     message_id: Some(message_id.to_string()),
                     verification: Some(reason),
                     stage: Some(DeliveryStage::Inject),
@@ -379,6 +369,18 @@ pub fn deliver_pending_message(
                     channel: None,
                 });
             }
+            store.mark(message_id, "target_resolved", Some(&reason))?;
+            return Ok(DeliveryOutcome {
+                ok: false,
+                status: DeliveryStatus::Degraded,
+                message_status: MessageStatusShadow("target_resolved".to_string()),
+                message_id: Some(message_id.to_string()),
+                verification: Some(reason),
+                stage: Some(DeliveryStage::Inject),
+                reason: None,
+                channel: None,
+            });
+        }
     };
     let submit_verified = inject_submit_verified(&inject_report);
     let readback_verified = pane_readback_verified(&inject_report);
@@ -404,8 +406,7 @@ pub fn deliver_pending_message(
         // legacy keys (`message_id` / `recipient` / `reason` / `attempts`)
         // are preserved byte-for-byte for grep compatibility; new keys are
         // ADDITIONAL.
-        let submit_attempts_detail =
-            render_submit_diagnostics(&inject_report);
+        let submit_attempts_detail = render_submit_diagnostics(&inject_report);
         event_log.write(
             "send.unverified",
             serde_json::json!({
@@ -461,14 +462,15 @@ pub fn deliver_pending_message(
     // per-delivery check / short grace window. Phase-1 Claude only —
     // codex/copilot keep the pre-fix behaviour (will be addressed in
     // phase-2 once Claude phase-1 is field-validated).
-    if let Some((rollout_path, provider_wire_str)) = claude_recipient_rollout(state, &message.recipient) {
+    if let Some((rollout_path, provider_wire_str)) =
+        claude_recipient_rollout(state, &message.recipient)
+    {
         let token_marker = format!("[team-agent-token:{message_id}]");
         let grace = std::time::Duration::from_millis(200);
         let deadline = std::time::Instant::now() + std::time::Duration::from_millis(500);
         let mut transcript_has_token = false;
         loop {
-            transcript_has_token =
-                rollout_tail_contains(&rollout_path, &token_marker, 64 * 1024);
+            transcript_has_token = rollout_tail_contains(&rollout_path, &token_marker, 64 * 1024);
             if transcript_has_token || std::time::Instant::now() >= deadline {
                 break;
             }
@@ -589,7 +591,12 @@ pub(crate) fn pane_readback_verified(report: &InjectReport) -> bool {
 /// when it sees this block + extracts the token — the bare content gives WORKING but never a report
 /// (rt-host-a loop #4). token == message_id (exactly-once correlation).
 /// F1 (0.3.26): promoted to `pub` for direct pane send in cli/send.rs.
-pub fn render_message(sender: &str, task_id: Option<&str>, content: &str, message_id: &str) -> String {
+pub fn render_message(
+    sender: &str,
+    task_id: Option<&str>,
+    content: &str,
+    message_id: &str,
+) -> String {
     let mut header = format!("Team Agent message from {sender}");
     if let Some(task_id) = task_id.filter(|t| !t.is_empty()) {
         header.push_str(&format!(" for {task_id}"));
@@ -717,8 +724,7 @@ fn pane_conflicts_on_same_socket(
     worker_socket: Option<&str>,
     leader: PaneSocketBinding<'_>,
 ) -> bool {
-    leader.pane_id == pane_id
-        && !tmux_sockets_known_different(worker_socket, leader.tmux_socket)
+    leader.pane_id == pane_id && !tmux_sockets_known_different(worker_socket, leader.tmux_socket)
 }
 
 fn tmux_sockets_known_different(left: Option<&str>, right: Option<&str>) -> bool {
@@ -784,7 +790,10 @@ fn leader_receiver_pane_is_usable(
     let Some(pane_id) = leader_receiver_pane_id(state) else {
         return false;
     };
-    if live_targets.iter().any(|target| target.pane_id.as_str() == pane_id) {
+    if live_targets
+        .iter()
+        .any(|target| target.pane_id.as_str() == pane_id)
+    {
         return true;
     }
     !matches!(
@@ -1228,11 +1237,12 @@ fn recipient_pane_has_actionable_startup_prompt(
         .and_then(|agents| agents.get(recipient));
     let provider = agent
         .and_then(|agent| agent.get("provider"))
-        .and_then(serde_json::Value::as_str);
-    if !matches!(
-        provider,
-        Some("codex" | "claude" | "claude_code" | "copilot")
-    ) {
+        .and_then(serde_json::Value::as_str)
+        .and_then(parse_canonical_provider);
+    let Some(provider) = provider else {
+        return false;
+    };
+    if matches!(provider, Provider::GeminiCli | Provider::Fake) {
         return false;
     }
     // step2-retry/scrollback root-cause (rt binary 6c9c6c1c): once the agent's
@@ -1264,20 +1274,20 @@ fn recipient_pane_has_actionable_startup_prompt(
         _ => return false,
     };
     match provider {
-        Some("codex") => matches!(
+        Provider::Codex => matches!(
             crate::provider::classify_codex_startup_screen(&captured),
             crate::provider::StartupScreenDecision::AnswerWorkspaceTrust
                 | crate::provider::StartupScreenDecision::SkipUpdatePrompt
         ),
-        Some("claude" | "claude_code") => matches!(
+        Provider::Claude | Provider::ClaudeCode => matches!(
             crate::provider::classify_claude_startup_screen(&captured),
             crate::provider::StartupScreenDecision::AnswerWorkspaceTrust
         ),
-        Some("copilot") => matches!(
+        Provider::Copilot => matches!(
             crate::provider::classify_copilot_startup_screen(&captured),
             crate::provider::StartupScreenDecision::AnswerWorkspaceTrust
         ),
-        _ => false,
+        Provider::GeminiCli | Provider::Fake => false,
     }
 }
 
@@ -1410,8 +1420,20 @@ fn record_turn_open_if_leader_to_worker_scoped(
         return Ok(());
     }
     let mut state = scoped_state_for_write(workspace, owner_team_id)?;
+    arm_turn_open(&mut state, recipient, &delivered.message_id);
+    save_scoped_state_reapplying_after_conflict(workspace, &state, owner_team_id, |latest| {
+        arm_turn_open(latest, recipient, &delivered.message_id);
+    })?;
+    event_log.write(
+        "turn_open.armed_after_delivery",
+        serde_json::json!({"agent_id": recipient, "message_id": delivered.message_id}),
+    )?;
+    Ok(())
+}
+
+fn arm_turn_open(state: &mut serde_json::Value, recipient: &str, message_id: &Option<String>) {
     let Some(root) = state.as_object_mut() else {
-        return Ok(());
+        return;
     };
     let coordinator = root
         .entry("coordinator")
@@ -1419,15 +1441,9 @@ fn record_turn_open_if_leader_to_worker_scoped(
     if let Some(obj) = coordinator.as_object_mut() {
         obj.insert(
             "turn_open".to_string(),
-            serde_json::json!({"armed": true, "node_id": recipient, "turn_id": delivered.message_id}),
+            serde_json::json!({"armed": true, "node_id": recipient, "turn_id": message_id}),
         );
     }
-    save_scoped_state(workspace, &state, owner_team_id)?;
-    event_log.write(
-        "turn_open.armed_after_delivery",
-        serde_json::json!({"agent_id": recipient, "message_id": delivered.message_id}),
-    )?;
-    Ok(())
 }
 
 /// `_stamp_first_send_at_if_leader_to_worker` (`delivery.py:380`):首次 leader→worker 投递戳
@@ -1453,6 +1469,15 @@ fn stamp_first_send_at_if_leader_to_worker_scoped(
     }
     let mut state = scoped_state_for_write(workspace, owner_team_id)?;
     let now = chrono::Utc::now().to_rfc3339();
+    if stamp_first_send_at(&mut state, recipient, &now) {
+        save_scoped_state_reapplying_after_conflict(workspace, &state, owner_team_id, |latest| {
+            let _ = stamp_first_send_at(latest, recipient, &now);
+        })?;
+    }
+    Ok(())
+}
+
+fn stamp_first_send_at(state: &mut serde_json::Value, recipient: &str, now: &str) -> bool {
     if let Some(agent) = state
         .get_mut("agents")
         .and_then(serde_json::Value::as_object_mut)
@@ -1464,11 +1489,14 @@ fn stamp_first_send_at_if_leader_to_worker_scoped(
                 .get("first_send_at")
                 .is_some_and(serde_json::Value::is_null)
         {
-            agent.insert("first_send_at".to_string(), serde_json::Value::String(now));
-            save_scoped_state(workspace, &state, owner_team_id)?;
+            agent.insert(
+                "first_send_at".to_string(),
+                serde_json::Value::String(now.to_string()),
+            );
+            return true;
         }
     }
-    Ok(())
+    false
 }
 
 fn scoped_state_for_write(
@@ -1516,6 +1544,40 @@ fn save_scoped_state(
     Ok(())
 }
 
+fn save_scoped_state_reapplying_after_conflict<F>(
+    workspace: &Path,
+    state: &serde_json::Value,
+    owner_team_id: Option<&str>,
+    reapply: F,
+) -> Result<(), MessagingError>
+where
+    F: FnOnce(&mut serde_json::Value),
+{
+    if owner_team_id.filter(|team| !team.is_empty()).is_some()
+        && state
+            .get("teams")
+            .and_then(serde_json::Value::as_object)
+            .is_some_and(|teams| {
+                owner_team_id
+                    .and_then(|team| {
+                        crate::state::projection::resolve_owner_team_id(state, team)
+                            .canonical_key()
+                            .map(str::to_string)
+                    })
+                    .is_some_and(|team| teams.contains_key(&team))
+            })
+    {
+        crate::state::projection::save_team_scoped_state_reapplying_after_conflict(
+            workspace, state, reapply,
+        )?;
+    } else {
+        crate::state::persist::save_runtime_state_reapplying_after_conflict(
+            workspace, state, reapply,
+        )?;
+    }
+    Ok(())
+}
+
 enum OwnerTeamProjection {
     Projected {
         state: serde_json::Value,
@@ -1765,12 +1827,14 @@ fn claude_recipient_rollout(
     recipient: &str,
 ) -> Option<(std::path::PathBuf, &'static str)> {
     let agent = state.get("agents")?.get(recipient)?;
-    let provider = agent.get("provider").and_then(serde_json::Value::as_str)?;
-    let provider_wire_str = match provider {
-        "claude" => "claude",
-        "claude_code" | "claude-code" => "claude_code",
-        _ => return None,
-    };
+    let provider = agent
+        .get("provider")
+        .and_then(serde_json::Value::as_str)
+        .and_then(parse_provider)?;
+    if !is_claude_family(provider) {
+        return None;
+    }
+    let provider_wire_str = provider_wire(provider);
     let rollout = agent
         .get("rollout_path")
         .and_then(serde_json::Value::as_str)

package/crates/team-agent/src/messaging/helpers.rs

@@ -131,6 +131,7 @@ pub(crate) fn working_seconds(scrollback: &str) -> Option<u64> {
 }
 
 pub(crate) fn non_provider_command(command: &str) -> Option<&str> {
+    // Activity command grammar, not provider identity parsing.
     let base = command.rsplit('/').next().unwrap_or(command);
     let normalized = base.to_ascii_lowercase();
     match normalized.as_str() {

package/crates/team-agent/src/messaging/leader_receiver.rs

@@ -269,7 +269,28 @@ pub fn claim_leader_receiver(
         .with_leader_receiver(receiver_value)
         .with_owner_epoch(next_epoch);
     crate::state::ownership::write_owner(state, &team_key, record);
-    crate::state::persist::save_runtime_state(workspace, state)?;
+    crate::state::persist::save_runtime_state_reapplying_after_conflict(
+        workspace,
+        state,
+        |latest| {
+            let team_key = crate::state::projection::team_state_key(latest);
+            let record = crate::state::ownership::OwnershipWrite::new()
+                .with_team_owner(
+                    state
+                        .get("team_owner")
+                        .cloned()
+                        .unwrap_or_else(|| serde_json::json!({})),
+                )
+                .with_leader_receiver(
+                    state
+                        .get("leader_receiver")
+                        .cloned()
+                        .unwrap_or_else(|| serde_json::json!({})),
+                )
+                .with_owner_epoch(next_epoch);
+            crate::state::ownership::write_owner(latest, &team_key, record);
+        },
+    )?;
     event_log.write(
         "leader_receiver.claimed",
         serde_json::json!({"owner_epoch": next_epoch, "candidate": candidate}),

package/crates/team-agent/src/messaging/results.rs

@@ -108,6 +108,7 @@ fn collect_scoped(
     let mut invalid_results = Vec::new();
     let mut fatal_invalid_results = 0usize;
     let mut state_dirty = false;
+    let mut task_updates = Vec::new();
     for row in rows {
         let envelope: serde_json::Value = match serde_json::from_str(&row.envelope) {
             Ok(envelope) => envelope,
@@ -167,6 +168,7 @@ fn collect_scoped(
         }
         if scope == "task" {
             mark_task_done(&mut state, &row.task_id, &row.result_id);
+            task_updates.push((row.task_id.clone(), row.result_id.clone()));
             state_dirty = true;
         }
         log.write(
@@ -196,9 +198,25 @@ fn collect_scoped(
     }
     if state_dirty {
         if owner_team_id.is_some() {
-            crate::state::projection::save_team_scoped_state(&paths.run_workspace, &state)?;
+            crate::state::projection::save_team_scoped_state_reapplying_after_conflict(
+                &paths.run_workspace,
+                &state,
+                |latest| {
+                    for (task_id, result_id) in &task_updates {
+                        mark_task_done(latest, task_id, result_id);
+                    }
+                },
+            )?;
         } else {
-            crate::state::persist::save_runtime_state(&paths.run_workspace, &state)?;
+            crate::state::persist::save_runtime_state_reapplying_after_conflict(
+                &paths.run_workspace,
+                &state,
+                |latest| {
+                    for (task_id, result_id) in &task_updates {
+                        mark_task_done(latest, task_id, result_id);
+                    }
+                },
+            )?;
         }
     }
     let counts = result_counts(&conn, owner_team_id)?;
@@ -708,8 +726,10 @@ fn report_result_for_owner_team_inner(
         Ok(outcome) => outcome,
         Err(error) => {
             let message_id = format!("fallback:{result_id}");
-            let fallback_error =
-                fallback_primary_error_text(fallback_primary_error, format!("leader_funnel_error:{error}"));
+            let fallback_error = fallback_primary_error_text(
+                fallback_primary_error,
+                format!("leader_funnel_error:{error}"),
+            );
             super::leader_receiver::deliver_to_leader_fallback_pane(
                 workspace,
                 &state,
@@ -1027,9 +1047,11 @@ fn format_report_result_changes(envelope: &serde_json::Value) -> Option<String>
         .filter_map(|change| {
             let path = report_field_any(change, &["path", "file", "filepath", "filename"])?;
             let kind = report_field_any(change, &["kind", "type", "action"]).unwrap_or("changed");
-            let description =
-                report_field_any(change, &["description", "summary", "detail", "details", "message"])
-                    .unwrap_or(path);
+            let description = report_field_any(
+                change,
+                &["description", "summary", "detail", "details", "message"],
+            )
+            .unwrap_or(path);
             Some(format!("{kind} {path}: {description}"))
         })
         .collect::<Vec<_>>();
@@ -1078,8 +1100,11 @@ fn format_report_result_next_actions(envelope: &serde_json::Value) -> Option<Str
     let parts = report_result_array(envelope, "next_actions")?
         .iter()
         .filter_map(|action| {
-            report_field_any(action, &["description", "summary", "action", "todo", "message"])
-                .map(|text| text.to_string())
+            report_field_any(
+                action,
+                &["description", "summary", "action", "todo", "message"],
+            )
+            .map(|text| text.to_string())
         })
         .collect::<Vec<_>>();
     if parts.is_empty() {