@team-agent/installer 0.5.41 → 0.5.43

package/crates/team-agent/src/platform/process.rs

@@ -53,9 +53,7 @@ pub enum TerminationOutcome {
     /// Windows downgraded `TerminateGraceful` to `TerminateProcess`
     /// (no grace period). Includes a machine-readable reason so
     /// callers can log it in the audit event.
-    ForceOnly {
-        reason: &'static str,
-    },
+    ForceOnly { reason: &'static str },
     /// The pid/group was already gone by the time the call resolved.
     /// Not an error.
     AlreadyGone,
@@ -166,10 +164,7 @@ mod unix_impl {
     /// downgrade path); the `AlreadyGone` case is preserved when
     /// `kill()` returns ESRCH (the target was reaped between check
     /// and send).
-    pub fn terminate_pid(
-        pid: u32,
-        kind: SignalKind,
-    ) -> Result<TerminationOutcome, io::Error> {
+    pub fn terminate_pid(pid: u32, kind: SignalKind) -> Result<TerminationOutcome, io::Error> {
         let signal = match kind {
             SignalKind::TerminateGraceful => libc::SIGTERM,
             SignalKind::TerminateForce => libc::SIGKILL,
@@ -275,12 +270,16 @@ mod windows_impl {
         while result.is_ok() {
             if entry.th32ProcessID == my_pid {
                 let ppid = entry.th32ParentProcessID;
-                unsafe { let _ = windows::Win32::Foundation::CloseHandle(snapshot); };
+                unsafe {
+                    let _ = windows::Win32::Foundation::CloseHandle(snapshot);
+                };
                 return Some(ppid);
             }
             result = unsafe { Process32NextW(snapshot, &mut entry) };
         }
-        unsafe { let _ = windows::Win32::Foundation::CloseHandle(snapshot); };
+        unsafe {
+            let _ = windows::Win32::Foundation::CloseHandle(snapshot);
+        };
         None
     }
 
@@ -327,7 +326,9 @@ mod windows_impl {
         };
         let mut exit_code: u32 = 0;
         let result = unsafe { GetExitCodeProcess(handle, &mut exit_code) };
-        unsafe { let _ = CloseHandle(handle); };
+        unsafe {
+            let _ = CloseHandle(handle);
+        };
         result.map_err(|e| io::Error::from_raw_os_error(e.code().0 as i32))?;
         // `STILL_ACTIVE` (0x103) — the process is still running.
         if exit_code == STILL_ACTIVE.0 as u32 {
@@ -358,14 +359,9 @@ mod windows_impl {
         Ok(Vec::new())
     }
 
-    pub fn terminate_pid(
-        pid: u32,
-        kind: SignalKind,
-    ) -> Result<TerminationOutcome, io::Error> {
+    pub fn terminate_pid(pid: u32, kind: SignalKind) -> Result<TerminationOutcome, io::Error> {
         use windows::Win32::Foundation::CloseHandle;
-        use windows::Win32::System::Threading::{
-            OpenProcess, TerminateProcess, PROCESS_TERMINATE,
-        };
+        use windows::Win32::System::Threading::{OpenProcess, TerminateProcess, PROCESS_TERMINATE};
         // CR C-6 anchor: Windows has no SIGTERM analogue for a
         // non-console child. `TerminateGraceful` cannot be honored;
         // we still perform the physical `TerminateProcess` (design
@@ -394,7 +390,9 @@ mod windows_impl {
             }
         };
         let result = unsafe { TerminateProcess(handle, 1) };
-        unsafe { let _ = CloseHandle(handle); };
+        unsafe {
+            let _ = CloseHandle(handle);
+        };
         result.map_err(|e| io::Error::from_raw_os_error(e.code().0 as i32))?;
         Ok(match kind {
             SignalKind::TerminateGraceful => TerminationOutcome::ForceOnly {
@@ -444,7 +442,10 @@ mod tests {
         // Windows (Toolhelp32 snapshot) return the process's parent
         // pid. A `None` here on either platform is a regression.
         let ppid = current_parent_pid();
-        assert!(ppid.is_some(), "current_parent_pid must return Some on both unix and windows");
+        assert!(
+            ppid.is_some(),
+            "current_parent_pid must return Some on both unix and windows"
+        );
         assert!(ppid.unwrap() > 0);
     }
 
@@ -544,9 +545,7 @@ mod tests {
         // pattern-match without cfg.
         assert_ne!(SignalKind::TerminateGraceful, SignalKind::TerminateForce);
         let requested = TerminationOutcome::Requested;
-        let force_only = TerminationOutcome::ForceOnly {
-            reason: "test",
-        };
+        let force_only = TerminationOutcome::ForceOnly { reason: "test" };
         let already_gone = TerminationOutcome::AlreadyGone;
         assert_ne!(requested, force_only);
         assert_ne!(requested, already_gone);

package/crates/team-agent/src/provider/adapters/claude.rs

@@ -8,9 +8,7 @@
 //! helpers now live under `provider/session_scan/claude.rs`.
 
 use crate::model::enums::AuthMode;
-use crate::provider::adapter::{
-    next_session_token, prompt_needs_native_mcp, BasicProviderAdapter,
-};
+use crate::provider::adapter::{next_session_token, prompt_needs_native_mcp, BasicProviderAdapter};
 use crate::provider::{McpConfig, ProviderAdapter, ProviderError};
 
 pub(crate) fn claude_launch_command(

package/crates/team-agent/src/provider/approvals/parsing.rs

@@ -49,7 +49,11 @@ pub fn active_approval_control_index(lines: &[&str]) -> Option<usize> {
         .rev()
         .find(|(_, line)| is_control_line(&clean_line(line)))
         .map(|(idx, _)| idx)?;
-    if lines.iter().skip(idx + 1).any(|line| !clean_line(line).is_empty()) {
+    if lines
+        .iter()
+        .skip(idx + 1)
+        .any(|line| !clean_line(line).is_empty())
+    {
         return None;
     }
     Some(idx)
@@ -61,15 +65,39 @@ pub fn extract_approval_prompt(agent_id: &str, capture: &str) -> Option<Approval
 
     if let Some((matched_idx, prompt, server, tool)) = explicit_mcp_prompt(&lines, control_idx) {
         let choices = approval_choices_between(&lines, matched_idx, control_idx);
-        return Some(approval(agent_id, ApprovalKind::McpTool, prompt, choices, Some(server), Some(tool), None));
+        return Some(approval(
+            agent_id,
+            ApprovalKind::McpTool,
+            prompt,
+            choices,
+            Some(server),
+            Some(tool),
+            None,
+        ));
     }
     if let Some((matched_idx, prompt, server, tool)) = short_mcp_prompt(&lines, control_idx) {
         let choices = approval_choices_between(&lines, matched_idx, control_idx);
-        return Some(approval(agent_id, ApprovalKind::McpTool, prompt, choices, Some(server), Some(tool), None));
+        return Some(approval(
+            agent_id,
+            ApprovalKind::McpTool,
+            prompt,
+            choices,
+            Some(server),
+            Some(tool),
+            None,
+        ));
     }
     if let Some((matched_idx, prompt, command)) = command_prompt(&lines, control_idx) {
         let choices = approval_choices_between(&lines, matched_idx, control_idx);
-        return Some(approval(agent_id, ApprovalKind::Command, prompt, choices, None, None, Some(command)));
+        return Some(approval(
+            agent_id,
+            ApprovalKind::Command,
+            prompt,
+            choices,
+            None,
+            None,
+            Some(command),
+        ));
     }
     let choices = approval_choices_between(&lines, 0, control_idx);
     Some(approval(
@@ -84,7 +112,11 @@ pub fn extract_approval_prompt(agent_id: &str, capture: &str) -> Option<Approval
 }
 
 pub fn choose_internal_mcp_approval_choice(prompt: &ApprovalPrompt) -> String {
-    if prompt.choices.iter().any(|choice| choice == "Allow for this session") {
+    if prompt
+        .choices
+        .iter()
+        .any(|choice| choice == "Allow for this session")
+    {
         return "Allow for this session".to_string();
     }
     for choice in &prompt.choices {
@@ -100,8 +132,16 @@ pub fn choose_internal_mcp_approval_choice(prompt: &ApprovalPrompt) -> String {
     "Allow for this session".to_string()
 }
 
-pub fn approval_choice_keys(prompt: &ApprovalPrompt, capture: &str, target_choice: &str) -> Vec<String> {
-    let Some(target_index) = prompt.choices.iter().position(|choice| choice == target_choice) else {
+pub fn approval_choice_keys(
+    prompt: &ApprovalPrompt,
+    capture: &str,
+    target_choice: &str,
+) -> Vec<String> {
+    let Some(target_index) = prompt
+        .choices
+        .iter()
+        .position(|choice| choice == target_choice)
+    else {
         return vec!["Down".to_string(), "Enter".to_string()];
     };
     let Some(active) = active_choice_index(capture) else {
@@ -145,7 +185,10 @@ fn is_control_line(line: &str) -> bool {
         || (lower.contains("esc to cancel") && lower.contains("tab to amend"))
 }
 
-fn explicit_mcp_prompt(lines: &[&str], control_idx: usize) -> Option<(usize, String, String, String)> {
+fn explicit_mcp_prompt(
+    lines: &[&str],
+    control_idx: usize,
+) -> Option<(usize, String, String, String)> {
     for (idx, raw) in lines.iter().enumerate().take(control_idx).rev() {
         let line = clean_line(raw);
         let prefix = "Allow the ";
@@ -171,10 +214,20 @@ fn short_mcp_prompt(lines: &[&str], control_idx: usize) -> Option<(usize, String
             continue;
         }
         if let Some(tool) = team_orchestrator_tool(&line, '-') {
-            return Some((idx, format!("team_orchestrator - {tool}"), "team_orchestrator".to_string(), tool));
+            return Some((
+                idx,
+                format!("team_orchestrator - {tool}"),
+                "team_orchestrator".to_string(),
+                tool,
+            ));
         }
         if let Some(tool) = team_orchestrator_tool(&line, '.') {
-            return Some((idx, format!("team_orchestrator - {tool}"), "team_orchestrator".to_string(), tool));
+            return Some((
+                idx,
+                format!("team_orchestrator - {tool}"),
+                "team_orchestrator".to_string(),
+                tool,
+            ));
         }
     }
     None
@@ -192,7 +245,12 @@ fn team_orchestrator_tool(line: &str, separator: char) -> Option<String> {
         .chars()
         .take_while(|ch| ch.is_ascii_alphanumeric() || *ch == '_')
         .collect();
-    if tool.is_empty() || !tool.chars().next().is_some_and(|ch| ch.is_ascii_alphabetic() || ch == '_') {
+    if tool.is_empty()
+        || !tool
+            .chars()
+            .next()
+            .is_some_and(|ch| ch.is_ascii_alphabetic() || ch == '_')
+    {
         None
     } else {
         Some(tool)
@@ -300,7 +358,10 @@ mod tests {
         assert_eq!(prompt.kind, ApprovalKind::McpTool);
         assert_eq!(prompt.server.as_deref(), Some("team_orchestrator"));
         assert_eq!(prompt.tool.as_deref(), Some("send_message"));
-        assert_eq!(prompt.prompt, "Allow the team_orchestrator MCP server to run tool \"send_message\"?");
+        assert_eq!(
+            prompt.prompt,
+            "Allow the team_orchestrator MCP server to run tool \"send_message\"?"
+        );
         assert_eq!(prompt.choices, vec!["Allow for this session", "Deny"]);
     }
 
@@ -338,7 +399,10 @@ mod tests {
         .unwrap();
         assert_eq!(prompt.kind, ApprovalKind::Command);
         assert_eq!(prompt.command.as_deref(), Some("Bash(echo hi)"));
-        assert_eq!(prompt.prompt, "Would you like to run the following command?");
+        assert_eq!(
+            prompt.prompt,
+            "Would you like to run the following command?"
+        );
     }
 
     #[test]
@@ -348,7 +412,10 @@ mod tests {
             None
         );
         assert_eq!(
-            extract_approval_prompt("agent-x", "MCP tool: team_orchestrator - send_message requires approval\n  1. Allow\n"),
+            extract_approval_prompt(
+                "agent-x",
+                "MCP tool: team_orchestrator - send_message requires approval\n  1. Allow\n"
+            ),
             None
         );
     }
@@ -381,10 +448,20 @@ mod tests {
             None,
             None,
         );
-        assert_eq!(choose_internal_mcp_approval_choice(&prompt), "Allow for this session");
+        assert_eq!(
+            choose_internal_mcp_approval_choice(&prompt),
+            "Allow for this session"
+        );
         prompt.choices = vec!["Maybe".to_string()];
-        assert_eq!(choose_internal_mcp_approval_choice(&prompt), "Allow for this session");
-        prompt.choices = vec!["Maybe".to_string(), "Yes, and don't ask again for this command".to_string(), "Allow".to_string()];
+        assert_eq!(
+            choose_internal_mcp_approval_choice(&prompt),
+            "Allow for this session"
+        );
+        prompt.choices = vec![
+            "Maybe".to_string(),
+            "Yes, and don't ask again for this command".to_string(),
+            "Allow".to_string(),
+        ];
         assert_eq!(
             choose_internal_mcp_approval_choice(&prompt),
             "Yes, and don't ask again for this command"
@@ -402,11 +479,26 @@ mod tests {
             None,
             None,
         );
-        assert_eq!(approval_choice_keys(&prompt, "❯ 1. Allow\n", "Missing"), vec!["Down", "Enter"]);
-        assert_eq!(approval_choice_keys(&prompt, "  1. Allow\n  2. Deny\n", "Deny"), vec!["2", "Enter"]);
-        assert_eq!(approval_choice_keys(&prompt, "❯ 1. Allow\n  2. Deny\n", "Deny"), vec!["Down", "Enter"]);
-        assert_eq!(approval_choice_keys(&prompt, "  1. Allow\n❯ 2. Deny\n", "Allow"), vec!["Up", "Enter"]);
-        assert_eq!(approval_choice_keys(&prompt, "❯ 1. Allow\n  2. Deny\n", "Allow"), vec!["Enter"]);
+        assert_eq!(
+            approval_choice_keys(&prompt, "❯ 1. Allow\n", "Missing"),
+            vec!["Down", "Enter"]
+        );
+        assert_eq!(
+            approval_choice_keys(&prompt, "  1. Allow\n  2. Deny\n", "Deny"),
+            vec!["2", "Enter"]
+        );
+        assert_eq!(
+            approval_choice_keys(&prompt, "❯ 1. Allow\n  2. Deny\n", "Deny"),
+            vec!["Down", "Enter"]
+        );
+        assert_eq!(
+            approval_choice_keys(&prompt, "  1. Allow\n❯ 2. Deny\n", "Allow"),
+            vec!["Up", "Enter"]
+        );
+        assert_eq!(
+            approval_choice_keys(&prompt, "❯ 1. Allow\n  2. Deny\n", "Allow"),
+            vec!["Enter"]
+        );
     }
 
     #[test]
@@ -445,8 +537,16 @@ mod tests {
             None,
         )
         .to_ordered_value();
-        let keys: Vec<&str> = mcp.as_object().unwrap().keys().map(String::as_str).collect();
-        assert_eq!(keys, vec!["agent_id", "state", "kind", "tool", "prompt", "choices"]);
+        let keys: Vec<&str> = mcp
+            .as_object()
+            .unwrap()
+            .keys()
+            .map(String::as_str)
+            .collect();
+        assert_eq!(
+            keys,
+            vec!["agent_id", "state", "kind", "tool", "prompt", "choices"]
+        );
 
         let command = approval(
             "agent-x",
@@ -458,8 +558,16 @@ mod tests {
             Some("Bash(echo hi)".to_string()),
         )
         .to_ordered_value();
-        let keys: Vec<&str> = command.as_object().unwrap().keys().map(String::as_str).collect();
-        assert_eq!(keys, vec!["agent_id", "state", "kind", "command", "prompt", "choices"]);
+        let keys: Vec<&str> = command
+            .as_object()
+            .unwrap()
+            .keys()
+            .map(String::as_str)
+            .collect();
+        assert_eq!(
+            keys,
+            vec!["agent_id", "state", "kind", "command", "prompt", "choices"]
+        );
     }
 
     #[test]

package/crates/team-agent/src/provider/approvals/runtime_prompts.rs

@@ -13,7 +13,10 @@ pub fn runtime_mcp_tool_allowlisted(tool: &str) -> bool {
 
 pub fn runtime_mcp_prompt_allowlisted(prompt: &ApprovalPrompt) -> bool {
     prompt.server.as_deref() == Some(RUNTIME_MCP_APPROVAL_SERVER)
-        && prompt.tool.as_deref().is_some_and(runtime_mcp_tool_allowlisted)
+        && prompt
+            .tool
+            .as_deref()
+            .is_some_and(runtime_mcp_tool_allowlisted)
 }
 
 /// Issue 1 (Round 3b gate review §6): Team-Agent control-plane MCP tools
@@ -126,7 +129,11 @@ pub fn awaiting_human_confirm_reason(
     }
 }
 
-pub fn approval_prompt_fingerprint(team: &str, agent_id: &str, prompt: &ApprovalPrompt) -> ApprovalFingerprint {
+pub fn approval_prompt_fingerprint(
+    team: &str,
+    agent_id: &str,
+    prompt: &ApprovalPrompt,
+) -> ApprovalFingerprint {
     let mut hasher = Sha256::new();
     hasher.update(team.as_bytes());
     hasher.update([0]);
@@ -161,7 +168,10 @@ pub fn awaiting_human_confirm_dedupe_key(
     agent_id: &str,
     fingerprint: &ApprovalFingerprint,
 ) -> String {
-    format!("awaiting_human_confirm:{team}:{agent_id}:{}", fingerprint.as_str())
+    format!(
+        "awaiting_human_confirm:{team}:{agent_id}:{}",
+        fingerprint.as_str()
+    )
 }
 
 pub fn awaiting_human_confirm_fact(

package/crates/team-agent/src/provider/classify.rs

@@ -3,8 +3,8 @@
 
 use super::helpers::parse_jsonl_records;
 use super::types::{
-    ClassifyResult, ClassifySource, FactKind, FaultFact, NoPingReason, ProcessLiveness, ProviderError,
-    RemindResult, Signature, TurnId, TurnState,
+    ClassifyResult, ClassifySource, FactKind, FaultFact, NoPingReason, ProcessLiveness,
+    ProviderError, RemindResult, Signature, TurnId, TurnState,
 };
 use super::Provider;
 
@@ -116,14 +116,20 @@ fn collect_background_open_ids(value: &serde_json::Value, out: &mut Vec<String>)
     match value {
         serde_json::Value::String(s) => {
             for piece in s.split(MARKER).skip(1) {
-                let id: String = piece.chars().take_while(|c| !c.is_whitespace() && *c != '\n').collect();
+                let id: String = piece
+                    .chars()
+                    .take_while(|c| !c.is_whitespace() && *c != '\n')
+                    .collect();
                 if !id.is_empty() {
                     out.push(id);
                 }
             }
         }
         serde_json::Value::Object(map) => {
-            if let Some(id) = map.get("backgroundTaskId").and_then(serde_json::Value::as_str) {
+            if let Some(id) = map
+                .get("backgroundTaskId")
+                .and_then(serde_json::Value::as_str)
+            {
                 if !id.is_empty() {
                     out.push(id.to_string());
                 }
@@ -147,9 +153,15 @@ fn collect_background_close_ids(value: &serde_json::Value, out: &mut Vec<String>
     // Form B: <task-notification> wrapper in a string with a status tag.
     if let serde_json::Value::Object(map) = value {
         if let Some(bash) = map.get("bashOutput").and_then(serde_json::Value::as_object) {
-            let status = bash.get("status").and_then(serde_json::Value::as_str).unwrap_or("");
+            let status = bash
+                .get("status")
+                .and_then(serde_json::Value::as_str)
+                .unwrap_or("");
             if matches!(status, "completed" | "failed" | "killed") {
-                if let Some(id) = bash.get("backgroundTaskId").and_then(serde_json::Value::as_str) {
+                if let Some(id) = bash
+                    .get("backgroundTaskId")
+                    .and_then(serde_json::Value::as_str)
+                {
                     if !id.is_empty() {
                         out.push(id.to_string());
                     }
@@ -236,37 +248,90 @@ pub fn evaluate_takeover_reminder(
                 }
             }
             TurnState::Working => {
-                return Ok(remind(false, NoPingReason::Node(TurnState::Working), Vec::new(), None));
+                return Ok(remind(
+                    false,
+                    NoPingReason::Node(TurnState::Working),
+                    Vec::new(),
+                    None,
+                ));
             }
             TurnState::BlockedOnHuman => {
-                return Ok(remind(false, NoPingReason::Node(TurnState::BlockedOnHuman), Vec::new(), None));
+                return Ok(remind(
+                    false,
+                    NoPingReason::Node(TurnState::BlockedOnHuman),
+                    Vec::new(),
+                    None,
+                ));
             }
             TurnState::Abnormal => {
-                return Ok(remind(false, NoPingReason::Node(TurnState::Abnormal), Vec::new(), None));
+                return Ok(remind(
+                    false,
+                    NoPingReason::Node(TurnState::Abnormal),
+                    Vec::new(),
+                    None,
+                ));
             }
             TurnState::Unknown => {
-                return Ok(remind(false, NoPingReason::Node(TurnState::Unknown), Vec::new(), None));
+                return Ok(remind(
+                    false,
+                    NoPingReason::Node(TurnState::Unknown),
+                    Vec::new(),
+                    None,
+                ));
             }
         }
     }
 
     let Some(ms) = monitor_state else {
-        return Ok(remind(false, NoPingReason::NotArmedNoWorkerTurn, Vec::new(), None));
+        return Ok(remind(
+            false,
+            NoPingReason::NotArmedNoWorkerTurn,
+            Vec::new(),
+            None,
+        ));
     };
-    if ms.get("opened_worker_turn_since_ack").and_then(serde_json::Value::as_bool) != Some(true) {
-        return Ok(remind(false, NoPingReason::NotArmedNoWorkerTurn, Vec::new(), None));
+    if ms
+        .get("opened_worker_turn_since_ack")
+        .and_then(serde_json::Value::as_bool)
+        != Some(true)
+    {
+        return Ok(remind(
+            false,
+            NoPingReason::NotArmedNoWorkerTurn,
+            Vec::new(),
+            None,
+        ));
     }
     if ms.get("suppressed").and_then(serde_json::Value::as_bool) == Some(true) {
         return Ok(remind(false, NoPingReason::Acknowledged, Vec::new(), None));
     }
     let Some(all_idle_since) = ms.get("all_idle_since").and_then(serde_json::Value::as_f64) else {
-        return Ok(remind(false, NoPingReason::NotArmedNoWorkerTurn, Vec::new(), None));
+        return Ok(remind(
+            false,
+            NoPingReason::NotArmedNoWorkerTurn,
+            Vec::new(),
+            None,
+        ));
     };
-    if ms.get("pinged_for_episode").and_then(serde_json::Value::as_f64) == Some(all_idle_since) {
-        return Ok(remind(false, NoPingReason::AlreadyPingedThisEpisode, Vec::new(), None));
+    if ms
+        .get("pinged_for_episode")
+        .and_then(serde_json::Value::as_f64)
+        == Some(all_idle_since)
+    {
+        return Ok(remind(
+            false,
+            NoPingReason::AlreadyPingedThisEpisode,
+            Vec::new(),
+            None,
+        ));
     }
     if now_monotonic - all_idle_since < debounce_seconds {
-        return Ok(remind(false, NoPingReason::DebounceActive, Vec::new(), None));
+        return Ok(remind(
+            false,
+            NoPingReason::DebounceActive,
+            Vec::new(),
+            None,
+        ));
     }
     Ok(remind(
         true,
@@ -301,7 +366,10 @@ fn classify_result(
     }
 }
 
-fn extract_lifecycle_facts(provider: Provider, records: &[serde_json::Value]) -> Vec<LifecycleFact> {
+fn extract_lifecycle_facts(
+    provider: Provider,
+    records: &[serde_json::Value],
+) -> Vec<LifecycleFact> {
     records
         .iter()
         .filter_map(|record| match provider {
@@ -328,7 +396,9 @@ fn codex_latest_explicit_error_fact(record: &serde_json::Value) -> Option<FaultF
     }
     Some(FaultFact::new(
         Signature::new("turn_failed"),
-        turn.get("id").and_then(serde_json::Value::as_str).map(TurnId::new),
+        turn.get("id")
+            .and_then(serde_json::Value::as_str)
+            .map(TurnId::new),
         FactKind::Failed,
     ))
 }
@@ -431,29 +501,43 @@ fn claude_lifecycle_fact(record: &serde_json::Value) -> Option<LifecycleFact> {
         ));
     }
     if record_type == Some("assistant") {
-        let turn_id = record.get("requestId").and_then(serde_json::Value::as_str).map(TurnId::new);
+        let turn_id = record
+            .get("requestId")
+            .and_then(serde_json::Value::as_str)
+            .map(TurnId::new);
         let Some(stop_reason) = record
             .get("message")
             .and_then(|m| m.get("stop_reason"))
-            .and_then(serde_json::Value::as_str) else {
-                if record
-                    .get("message")
-                    .and_then(|m| m.get("content"))
-                    .and_then(serde_json::Value::as_array)
-                    .is_some()
-                {
-                    return Some(lifecycle(
-                        FactKind::TurnOpen,
-                        turn_id,
-                        "assistant_in_flight",
-                        vec!["assistant_in_flight".to_string()],
-                    ));
-                }
-                return None;
-            };
+            .and_then(serde_json::Value::as_str)
+        else {
+            if record
+                .get("message")
+                .and_then(|m| m.get("content"))
+                .and_then(serde_json::Value::as_array)
+                .is_some()
+            {
+                return Some(lifecycle(
+                    FactKind::TurnOpen,
+                    turn_id,
+                    "assistant_in_flight",
+                    vec!["assistant_in_flight".to_string()],
+                ));
+            }
+            return None;
+        };
         return match stop_reason {
-            "tool_use" => Some(lifecycle(FactKind::TurnOpen, turn_id, "open_turn", Vec::new())),
-            "end_turn" => Some(lifecycle(FactKind::TurnComplete, turn_id, "end_turn", Vec::new())),
+            "tool_use" => Some(lifecycle(
+                FactKind::TurnOpen,
+                turn_id,
+                "open_turn",
+                Vec::new(),
+            )),
+            "end_turn" => Some(lifecycle(
+                FactKind::TurnComplete,
+                turn_id,
+                "end_turn",
+                Vec::new(),
+            )),
             "stop_sequence" => Some(lifecycle(
                 FactKind::TurnComplete,
                 turn_id,
@@ -466,7 +550,10 @@ fn claude_lifecycle_fact(record: &serde_json::Value) -> Option<LifecycleFact> {
     if record_type == Some("user") && claude_user_interrupted(record) {
         return Some(lifecycle(
             FactKind::Interrupted,
-            record.get("uuid").and_then(serde_json::Value::as_str).map(TurnId::new),
+            record
+                .get("uuid")
+                .and_then(serde_json::Value::as_str)
+                .map(TurnId::new),
             "user_interrupt",
             vec!["interrupted".to_string()],
         ));
@@ -585,9 +672,7 @@ fn claude_user_interrupted(record: &serde_json::Value) -> bool {
         .is_some_and(|items| {
             items.iter().any(|item| {
                 item.get("type").and_then(serde_json::Value::as_str) == Some("text")
-                    && item
-                        .get("text")
-                        .and_then(serde_json::Value::as_str)
+                    && item.get("text").and_then(serde_json::Value::as_str)
                         == Some("[Request interrupted by user]")
             })
         })