refactor(#1474): replace too_many_arguments allows on pub fns with param structs

hive-ag3nt/src/bin/hive.rs

@@ -533,17 +533,17 @@ async fn handle_turn<S: Surface>(
         let ended_at = serve_common::now_unix();
         let duration_ms = i64::try_from(started_instant.elapsed().as_millis()).unwrap_or(i64::MAX);
         let (open_threads, open_reminders) = S::post_turn_counts(socket).await;
-        let row = serve_common::build_row(
+        let row = serve_common::build_row(serve_common::TurnRowArgs {
             started_at,
             ended_at,
             duration_ms,
-            model_at_start,
-            from.clone(),
-            &outcome,
+            model: model_at_start,
+            wake_from: from.clone(),
+            outcome: &outcome,
             bus,
-            open_threads,
-            open_reminders,
-        );
+            open_threads_count: open_threads,
+            open_reminders_count: open_reminders,
+        });
         stats.record(&row);
     }
     let pending = S::inbox_unread(socket).await;

hive-ag3nt/src/serve_common.rs

@@ -36,26 +36,36 @@ pub fn now_unix() -> i64 {
         .unwrap_or(0)
 }
 
+/// Field-named args for [`build_row`]. Mirrors the turn-stats row
+/// columns; `outcome` and `bus` borrow for the duration of the call.
+pub struct TurnRowArgs<'a> {
+    pub started_at: i64,
+    pub ended_at: i64,
+    pub duration_ms: i64,
+    pub model: String,
+    pub wake_from: String,
+    pub outcome: &'a TurnOutcome,
+    pub bus: &'a Bus,
+    pub open_threads_count: Option<u64>,
+    pub open_reminders_count: Option<u64>,
+}
+
 /// Assemble a `TurnStatRow` from the harness's per-turn state. Used by both
 /// the agent and manager serve loops — the shape is identical, only the
 /// post-turn count fetch helpers differ (and those stay in each binary).
 #[must_use]
-#[allow(
-    clippy::too_many_arguments,
-    reason = "args mirror the turn-stats row columns 1:1; a builder struct used \
-              only here would just relabel the same fields"
-)]
-pub fn build_row(
-    started_at: i64,
-    ended_at: i64,
-    duration_ms: i64,
-    model: String,
-    wake_from: String,
-    outcome: &TurnOutcome,
-    bus: &Bus,
-    open_threads_count: Option<u64>,
-    open_reminders_count: Option<u64>,
-) -> TurnStatRow {
+pub fn build_row(args: TurnRowArgs<'_>) -> TurnStatRow {
+    let TurnRowArgs {
+        started_at,
+        ended_at,
+        duration_ms,
+        model,
+        wake_from,
+        outcome,
+        bus,
+        open_threads_count,
+        open_reminders_count,
+    } = args;
     // Prefer the API-resolved model id (e.g. `claude-opus-4-8`) captured
     // from this turn's assistant events over the requested `--model`
     // name/alias, so the model-mix + cost rollup label the concrete