rename: open_threads → loose_ends + cancel_thread → cancel_loose_end across wire / tools / web ui

hive-c0re/src/agent_server.rs

@@ -174,8 +174,8 @@ async fn dispatch(req: &AgentRequest, agent: &str, coord: &Arc<Coordinator>) ->
             timing,
             file_path,
         } => handle_remind(coord, agent, message, timing, file_path.as_deref()),
-        AgentRequest::GetOpenThreads => match crate::open_threads::for_agent(coord, agent) {
-            Ok(threads) => AgentResponse::OpenThreads { threads },
+        AgentRequest::GetLooseEnds => match crate::loose_ends::for_agent(coord, agent) {
+            Ok(loose_ends) => AgentResponse::LooseEnds { loose_ends },
             Err(e) => AgentResponse::Err {
                 message: format!("{e:#}"),
             },
@@ -193,7 +193,7 @@ async fn dispatch(req: &AgentRequest, agent: &str, coord: &Arc<Coordinator>) ->
             role: "agent".to_owned(),
             hyperhive_rev: crate::auto_update::current_flake_rev(&coord.hyperhive_flake),
         },
-        AgentRequest::CancelThread { kind, id } => crate::questions::handle_cancel_thread(
+        AgentRequest::CancelLooseEnd { kind, id } => crate::questions::handle_cancel_loose_end(
             coord, agent, *kind, *id,
         )
         .map_or_else(

hive-c0re/src/loose_ends.rs

@@ -0,0 +1,153 @@
+//! Loose-ends aggregator. Walks the `approvals` + `operator_questions`
+//! tables once per call and assembles a `Vec<LooseEnd>` for either
+//! a single agent (`for_agent`) or the whole hive (`hive_wide`). Both
+//! `AgentRequest::GetLooseEnds` and `ManagerRequest::GetLooseEnds`
+//! land here so the routing logic + age-seconds derivation stay in
+//! one place.
+//!
+//! Call frequency is low (an agent doing self-introspection between
+//! turns), so the sweep happens fresh every time — no caching, no
+//! mutation events. If the sweep ever shows up in a profile, the
+//! sqlite queries already filter on the same indexes
+//! (`idx_approvals_pending` + `idx_operator_questions_pending`) that
+//! the dashboard uses, so the bottleneck would be json
+//! (de)serialisation, not the read.
+
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use anyhow::Result;
+use hive_sh4re::{MANAGER_AGENT, LooseEnd};
+
+use crate::coordinator::Coordinator;
+
+/// Open threads pending against `agent`:
+/// - pending approvals where this agent is the submitter (only ever
+///   true for the manager — sub-agents don't submit approvals — but
+///   we keep the rule per-agent so the manager's MCP surface gets
+///   the same shape via a different code path);
+/// - unanswered questions where `agent` is the asker (waiting on
+///   someone) OR the target (owes a reply);
+/// - pending reminders this agent scheduled (`owner == self`).
+///
+/// Ordered approvals → questions → reminders within the returned
+/// vector. Within each kind, source-of-truth ordering (sqlite's
+/// `pending()` queries return newest-first within their indexes).
+pub fn for_agent(coord: &Coordinator, agent: &str) -> Result<Vec<LooseEnd>> {
+    let now = now_unix();
+    let mut out = Vec::new();
+    // Approvals are only submitted by the manager today. When that
+    // expands (e.g. sub-agents propose changes to their own configs),
+    // teach the approvals table to track the submitter and filter
+    // here on that column — for now MANAGER_AGENT == sole submitter.
+    if agent == MANAGER_AGENT {
+        for a in coord.approvals.pending()? {
+            out.push(LooseEnd::Approval {
+                id: a.id,
+                agent: a.agent,
+                commit_ref: a.commit_ref,
+                description: a.description,
+                age_seconds: saturating_age(now, a.requested_at),
+            });
+        }
+    }
+    for q in coord.questions.pending_all()? {
+        let role_match = q.asker == agent || q.target.as_deref() == Some(agent);
+        if !role_match {
+            continue;
+        }
+        out.push(LooseEnd::Question {
+            id: q.id,
+            asker: q.asker,
+            target: q.target,
+            question: q.question,
+            age_seconds: saturating_age(now, q.asked_at),
+        });
+    }
+    for r in coord.broker.list_pending_reminders()? {
+        if r.agent != agent {
+            continue;
+        }
+        out.push(LooseEnd::Reminder {
+            id: r.id,
+            owner: r.agent,
+            message: r.message,
+            due_at: r.due_at,
+            age_seconds: saturating_age(now, r.created_at),
+        });
+    }
+    Ok(out)
+}
+
+/// Hive-wide loose-ends view: EVERY pending approval + EVERY
+/// unanswered question + EVERY pending reminder. Manager surface
+/// only; sub-agents can't see each other's threads via the agent
+/// surface (`for_agent` filters by name).
+pub fn hive_wide(coord: &Coordinator) -> Result<Vec<LooseEnd>> {
+    let now = now_unix();
+    let mut out = Vec::new();
+    for a in coord.approvals.pending()? {
+        out.push(LooseEnd::Approval {
+            id: a.id,
+            agent: a.agent,
+            commit_ref: a.commit_ref,
+            description: a.description,
+            age_seconds: saturating_age(now, a.requested_at),
+        });
+    }
+    for q in coord.questions.pending_all()? {
+        out.push(LooseEnd::Question {
+            id: q.id,
+            asker: q.asker,
+            target: q.target,
+            question: q.question,
+            age_seconds: saturating_age(now, q.asked_at),
+        });
+    }
+    for r in coord.broker.list_pending_reminders()? {
+        out.push(LooseEnd::Reminder {
+            id: r.id,
+            owner: r.agent,
+            message: r.message,
+            due_at: r.due_at,
+            age_seconds: saturating_age(now, r.created_at),
+        });
+    }
+    Ok(out)
+}
+
+fn saturating_age(now: i64, then: i64) -> u64 {
+    let delta = now.saturating_sub(then);
+    u64::try_from(delta).unwrap_or(0)
+}
+
+fn now_unix() -> i64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .ok()
+        .and_then(|d| i64::try_from(d.as_secs()).ok())
+        .unwrap_or(0)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn saturating_age_handles_clock_back_step() {
+        // `now` < `then`: caller's clock went backwards between rows.
+        // We saturate to 0 rather than returning a negative or
+        // wrapping around to ~u64::MAX (which would render as "27
+        // billion years ago" in the wake prompt).
+        assert_eq!(saturating_age(100, 200), 0);
+    }
+
+    #[test]
+    fn saturating_age_normal_case() {
+        assert_eq!(saturating_age(1_000_000, 999_990), 10);
+    }
+
+    #[test]
+    fn saturating_age_zero_when_equal() {
+        assert_eq!(saturating_age(42, 42), 0);
+    }
+}

hive-c0re/src/main.rs

@@ -20,10 +20,10 @@ mod events_vacuum;
 mod forge;
 mod lifecycle;
 mod limits;
+mod loose_ends;
 mod manager_server;
 mod meta;
 mod migrate;
-mod open_threads;
 mod operator_questions;
 mod questions;
 mod reminder_scheduler;

hive-c0re/src/manager_server.rs

@@ -329,8 +329,8 @@ async fn dispatch(req: &ManagerRequest, coord: &Arc<Coordinator>) -> ManagerResp
                 },
             }
         }
-        ManagerRequest::GetOpenThreads => match crate::open_threads::hive_wide(coord) {
-            Ok(threads) => ManagerResponse::OpenThreads { threads },
+        ManagerRequest::GetLooseEnds => match crate::loose_ends::hive_wide(coord) {
+            Ok(loose_ends) => ManagerResponse::LooseEnds { loose_ends },
             Err(e) => ManagerResponse::Err {
                 message: format!("{e:#}"),
             },
@@ -348,7 +348,7 @@ async fn dispatch(req: &ManagerRequest, coord: &Arc<Coordinator>) -> ManagerResp
             role: "manager".to_owned(),
             hyperhive_rev: crate::auto_update::current_flake_rev(&coord.hyperhive_flake),
         },
-        ManagerRequest::CancelThread { kind, id } => crate::questions::handle_cancel_thread(
+        ManagerRequest::CancelLooseEnd { kind, id } => crate::questions::handle_cancel_loose_end(
             coord,
             MANAGER_AGENT,
             *kind,

hive-c0re/src/questions.rs

@@ -129,20 +129,20 @@ pub fn handle_answer(
     Ok(())
 }
 
-/// Handle `CancelThread` from either surface. Dispatches by kind to
+/// Handle `CancelLooseEnd` from either surface. Dispatches by kind to
 /// either `OperatorQuestions::cancel` or `Broker::cancel_reminder_as`,
 /// both of which do their own auth check (canceller == owner /
 /// asker, or `operator`, or `manager`). On question cancel, fires
 /// the `QuestionAnswered` event back to the asker so the harness
 /// loop can react (mirrors the operator-cancel dashboard path).
-pub fn handle_cancel_thread(
+pub fn handle_cancel_loose_end(
     coord: &Arc<Coordinator>,
     canceller: &str,
-    kind: hive_sh4re::CancelThreadKind,
+    kind: hive_sh4re::CancelLooseEndKind,
     id: i64,
 ) -> Result<(), String> {
     match kind {
-        hive_sh4re::CancelThreadKind::Question => {
+        hive_sh4re::CancelLooseEndKind::Question => {
             let (question, asker, target) = coord
                 .questions
                 .cancel(id, canceller)
@@ -161,7 +161,7 @@ pub fn handle_cancel_thread(
             coord.emit_question_resolved(id, &sentinel, canceller, true, target.as_deref());
             Ok(())
         }
-        hive_sh4re::CancelThreadKind::Reminder => {
+        hive_sh4re::CancelLooseEndKind::Reminder => {
             let owner = coord
                 .broker
                 .cancel_reminder_as(id, canceller)