turn_stats: per-turn analytics sink

new sqlite table at /state/hyperhive-turn-stats.sqlite on each
agent's state dir. one row per claude turn captures identity
(model, wake_from, result_kind), timing (started/ended_at,
duration_ms), cost (input/output/cache_read/cache_creation token
counts), behaviour (tool_call_count + per-tool breakdown JSON),
and post-turn snapshot metrics (open_threads_count,
open_reminders_count).

wire additions:
- AgentRequest/ManagerRequest::CountPendingReminders +
  Broker::count_pending_reminders_for(agent)
- Bus::observe_stream + take_tool_calls — pumps the existing
  stdout stream-json, picks out tool_use blocks, accumulates per
  turn. bin loops fold the breakdown into each row.
- TurnStats::open_default + TurnStatRow + record() — best-effort
  inserts; failures log + don't block the harness.

both ag3nt and m1nd bins capture started_at + duration via
Instant::elapsed, fetch open-thread + reminder counts from
hive-c0re via the existing socket (post-turn, best-effort), and
record one row at turn_end. record_kind splits ok / failed /
prompt_too_long; failures carry the error message in note.

todo entries for host-side vacuum sweep + reading the table back
into agent/dashboard badges.

hive-c0re/src/agent_server.rs

@@ -180,6 +180,14 @@ async fn dispatch(req: &AgentRequest, agent: &str, coord: &Arc<Coordinator>) ->
                 message: format!("{e:#}"),
             },
         },
+        AgentRequest::CountPendingReminders => {
+            match coord.broker.count_pending_reminders_for(agent) {
+                Ok(count) => AgentResponse::PendingRemindersCount { count },
+                Err(e) => AgentResponse::Err {
+                    message: format!("{e:#}"),
+                },
+            }
+        }
     }
 }
 

hive-c0re/src/broker.rs

@@ -324,6 +324,19 @@ impl Broker {
             .context("list pending reminders")
     }
 
+    /// Count this agent's still-pending (un-delivered) reminders.
+    /// Used by the per-turn stats sink for a cheap "what was queued
+    /// at turn-end" snapshot.
+    pub fn count_pending_reminders_for(&self, agent: &str) -> Result<u64> {
+        let conn = self.conn.lock().unwrap();
+        let n: i64 = conn.query_row(
+            "SELECT COUNT(*) FROM reminders WHERE agent = ?1 AND sent_at IS NULL",
+            params![agent],
+            |row| row.get(0),
+        )?;
+        Ok(u64::try_from(n).unwrap_or(0))
+    }
+
     /// Delete a reminder by id. Returns the number of rows removed (0
     /// when the id never existed or was already delivered). Hard
     /// delete rather than soft so the row doesn't linger and confuse a

hive-c0re/src/manager_server.rs

@@ -335,6 +335,14 @@ async fn dispatch(req: &ManagerRequest, coord: &Arc<Coordinator>) -> ManagerResp
                 message: format!("{e:#}"),
             },
         },
+        ManagerRequest::CountPendingReminders => {
+            match coord.broker.count_pending_reminders_for(MANAGER_AGENT) {
+                Ok(count) => ManagerResponse::PendingRemindersCount { count },
+                Err(e) => ManagerResponse::Err {
+                    message: format!("{e:#}"),
+                },
+            }
+        }
     }
 }