feat(agent): phase 5 — inflight tracking for tool dispatch

Faithful port of DeepSeek-Reasonix src/core/inflight.ts (52 LOC).

InflightSet: authoritative running-id tracker. Thread-safe
(Mutex<HashSet<String>>). Cards derive spinner state from
inflight.has(call_id) instead of trusting end-event delivery.

- Loop creates InflightSet at run_loop start (Reasonix loop.ts:147)
- Sequential dispatch: inflight.add after ToolExecutionStart,
  inflight.delete after tool_result_message — finally-contract
- Parallel dispatch: inflight.add at preflight, inflight.delete
  inline for Immediate path and in spawned future for Prepared
- execute_tool_calls umbrella passes inflight through to children

Tests: 8 tests ported from Reasonix tests/inflight.test.ts.
All 198 agent_loop tests pass. Build + fmt clean.

Author: Yogthos

src/agent/agent_loop/inflight.rs

@@ -0,0 +1,145 @@
+//! Inflight set — authoritative running-id tracker.
+//!
+//! Faithful port of `DeepSeek-Reasonix/src/core/inflight.ts` (52 lines).
+//!
+//! UI cards consult `inflight.has(call_id)` to derive spinner state
+//! instead of trusting end-event delivery. The loop adds on dispatch
+//! entry and deletes in `finally` so every exit path cleans up.
+//!
+//! Thread-safe: wraps a `Mutex<HashSet<String>>` so multiple tokio
+//! tasks can add/delete ids concurrently (parallel tool dispatch).
+
+use std::collections::HashSet;
+use std::sync::{Arc, Mutex};
+
+/// Authoritative running-id set. Cards derive `running` from
+/// `has(id)` instead of trusting end-event delivery.
+#[derive(Debug, Clone, Default)]
+pub struct InflightSet {
+    ids: Arc<Mutex<HashSet<String>>>,
+}
+
+impl InflightSet {
+    pub fn new() -> Self {
+        Self {
+            ids: Arc::new(Mutex::new(HashSet::new())),
+        }
+    }
+
+    /// Add an id to the set. Idempotent — re-adding the same id is a no-op.
+    pub fn add(&self, id: &str) {
+        self.ids.lock().unwrap().insert(id.to_string());
+    }
+
+    /// Remove an id from the set. No-op if the id was not present.
+    pub fn delete(&self, id: &str) {
+        self.ids.lock().unwrap().remove(id);
+    }
+
+    /// Check whether an id is currently in the set.
+    pub fn has(&self, id: &str) -> bool {
+        self.ids.lock().unwrap().contains(id)
+    }
+
+    /// Number of ids currently in flight.
+    pub fn len(&self) -> usize {
+        self.ids.lock().unwrap().len()
+    }
+
+    /// True when no ids are in flight.
+    pub fn is_empty(&self) -> bool {
+        self.ids.lock().unwrap().is_empty()
+    }
+
+    /// Drop everything — used at session reset.
+    /// No-op on an empty set.
+    pub fn clear(&self) {
+        self.ids.lock().unwrap().clear();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn add_has_delete_round_trips() {
+        let s = InflightSet::new();
+        assert!(!s.has("a"));
+        s.add("a");
+        assert!(s.has("a"));
+        assert_eq!(s.len(), 1);
+        s.delete("a");
+        assert!(!s.has("a"));
+        assert_eq!(s.len(), 0);
+    }
+
+    #[test]
+    fn add_is_idempotent() {
+        let s = InflightSet::new();
+        s.add("a");
+        s.add("a");
+        s.add("a");
+        assert_eq!(s.len(), 1);
+        assert!(s.has("a"));
+    }
+
+    #[test]
+    fn delete_on_missing_id_is_noop() {
+        let s = InflightSet::new();
+        s.delete("never-added");
+        assert_eq!(s.len(), 0);
+    }
+
+    #[test]
+    fn clear_empties_the_set() {
+        let s = InflightSet::new();
+        s.add("a");
+        s.add("b");
+        assert_eq!(s.len(), 2);
+        s.clear();
+        assert_eq!(s.len(), 0);
+        assert!(!s.has("a"));
+        assert!(!s.has("b"));
+    }
+
+    #[test]
+    fn clear_on_empty_set_is_noop() {
+        let s = InflightSet::new();
+        s.clear();
+        assert_eq!(s.len(), 0);
+    }
+
+    #[test]
+    fn is_empty_reflects_state() {
+        let s = InflightSet::new();
+        assert!(s.is_empty());
+        s.add("a");
+        assert!(!s.is_empty());
+        s.delete("a");
+        assert!(s.is_empty());
+    }
+
+    /// Port of inflight.test.ts:89 — finally contract: id removed
+    /// even when work throws.
+    #[test]
+    fn finally_contract_id_removed_when_work_throws() {
+        let s = InflightSet::new();
+        s.add("job-1");
+        // Simulate work that fails; "finally" block deletes.
+        s.delete("job-1");
+        assert!(!s.has("job-1"));
+        assert_eq!(s.len(), 0);
+    }
+
+    /// Cloned InflightSet shares state.
+    #[test]
+    fn clones_share_state() {
+        let s1 = InflightSet::new();
+        let s2 = s1.clone();
+        s1.add("a");
+        assert!(s2.has("a"));
+        s2.delete("a");
+        assert!(!s1.has("a"));
+    }
+}

src/agent/agent_loop/mod.rs

@@ -28,6 +28,7 @@ pub mod bridge;
 #[cfg(test)]
 mod h7_smoke;
 pub mod hooks;
+pub mod inflight;
 pub mod integration;
 pub mod message;
 #[cfg(feature = "plugin")]

src/agent/agent_loop/run.rs

@@ -44,6 +44,7 @@
 use serde_json::Value;
 use tokio::sync::mpsc;
 
+use super::inflight::InflightSet;
 use super::message::{
     AssistantMessage, ContentBlock, LoopEvent, LoopMessage, StopReason, ToolResultMessage,
 };
@@ -187,6 +188,11 @@ pub async fn run_loop(
 ) -> Vec<LoopMessage> {
     let mut first_turn = true;
 
+    // Inflight set: authoritative running-id tracker.
+    // UI cards consult `inflight.has(call_id)` to derive spinner state.
+    // Port of Reasonix `loop.ts:147` InflightSet.
+    let inflight = InflightSet::new();
+
     // Pi line 167: initial steering poll.
     let mut pending_messages: Vec<LoopMessage> = match &config.get_steering_messages {
         Some(get) => get().await,
@@ -331,9 +337,15 @@ pub async fn run_loop(
             let mut tool_results: Vec<ToolResultMessage> = Vec::new();
             has_more_tool_calls = false;
             if !tool_calls.is_empty() {
-                let batch =
-                    execute_tool_calls(&current_context, &assistant_msg, &config, &signal, emit)
-                        .await;
+                let batch = execute_tool_calls(
+                    &current_context,
+                    &assistant_msg,
+                    &config,
+                    &signal,
+                    emit,
+                    &inflight,
+                )
+                .await;
                 tool_results = batch.messages;
                 has_more_tool_calls = !batch.terminate;
                 for result in &tool_results {