diff --git a/CLAUDE.md b/CLAUDE.md
index b135dea4..bba3919f 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -53,12 +53,11 @@ hive-c0re/         host daemon + CLI (one binary, subcommand-dispatched)
                          transient/sockets) + tombstone enumeration +
                          kick_agent + notify_agent (helper-event push) +
                          last_containers cache + rescan_and_emit diff helper
-  src/loose_ends.rs     loose-ends aggregator (pending approvals +
-                         unanswered questions + pending reminders) —
-                         for_agent (filtered) and hive_wide (manager
-                         surface). Backs AgentRequest::GetLooseEnds +
-                         ManagerRequest::GetLooseEnds (the
-                         get_loose_ends MCP tool).
+  src/open_threads.rs   loose-ends aggregator (pending approvals +
+                         unanswered questions) — for_agent (filtered) and
+                         hive_wide (manager surface). Backs
+                         AgentRequest::GetOpenThreads + ManagerRequest::
+                         GetOpenThreads (the get_open_threads MCP tool).
   src/actions.rs        approve/deny/destroy (transient-aware)
   src/auto_update.rs    startup rebuild scan + ensure_manager +
                          meta::lock_update_hyperhive bump
diff --git a/TODO.md b/TODO.md
index c4c2b864..86a825f0 100644
--- a/TODO.md
+++ b/TODO.md
@@ -40,7 +40,13 @@ how often the friction bites in normal use.
   into the prompt builder in `hive-ag3nt::turn.rs`. Even better: add a
   one-shot `recv_batch(max: u32)` MCP tool that returns up to `max`
   pending messages in a single round-trip.
-- ~~**Self-management of own asks + reminders**~~ ✓ landed — unified with `get_loose_ends` (renamed from `get_open_threads` per the naming pass). `LooseEnd` enum (renamed from `OpenThread`) gained a `Reminder { id, owner, message, due_at, age_seconds }` variant (sub-agent flavour filters by `owner == self`; manager unfiltered). New `mcp__hyperhive__cancel_loose_end(kind, id)` on both surfaces — `kind` is `"question"` (asker gets `[cancelled by <self>]` answer, unblocks) or `"reminder"` (hard-deleted before fire). Auth: sub-agent must own the row; manager bypasses for hive-wide cleanup. New helpers `OperatorQuestions::cancel` + `Broker::cancel_reminder_as` push the auth check down so both flavours stay aligned. Shared dispatch in `hive-c0re/src/questions.rs::handle_cancel_loose_end`. Per-agent web UI's `/api/open-threads` → `/api/loose-ends` too, with reminder-row rendering added.
+- **Self-management of own asks + reminders** — once I fire `ask` or
+  `remind` I have no way to inspect or cancel them from the agent side.
+  Operator can cancel asks via dashboard; nothing for reminders at all
+  (TODO above). Want `list_my_asks() -> [{id, target, question, asked_at}]`
+  and `cancel_ask(id)` on the agent surface, plus `list_my_reminders()`
+  / `cancel_reminder(id)`. Bounded by `asker == self` and `reminder.owner
+  == self` so no cross-agent meddling.
 - **Optional `in_reply_to: <msg_id>` on send** — pure wire addition; no
   behavioural change. The dashboard could render conversation threads
   (already wants this for the agent-to-agent question UI in the
diff --git a/hive-ag3nt/assets/app.js b/hive-ag3nt/assets/app.js
index 82b6c80f..709d9bd0 100644
--- a/hive-ag3nt/assets/app.js
+++ b/hive-ag3nt/assets/app.js
@@ -393,43 +393,43 @@
     }
     renderStateBadge();
   }
-  // Loose-ends section: same data the get_loose_ends MCP tool
+  // Open-threads section: same data the get_open_threads MCP tool
   // returns. Best-effort fetch on cold load + after every turn_end
   // (a turn likely answered or asked something). Silent failure
   // keeps the section hidden rather than surfacing an empty banner.
-  let lastLooseEndsCount = 0;
-  async function refreshLooseEnds() {
+  let lastOpenThreadsCount = 0;
+  async function refreshOpenThreads() {
     try {
-      const resp = await fetch('/api/loose-ends');
+      const resp = await fetch('/api/open-threads');
       if (!resp.ok) {
-        renderLooseEnds([]);
+        renderOpenThreads([]);
         return;
       }
       const data = await resp.json();
-      renderLooseEnds(data.loose_ends || []);
+      renderOpenThreads(data.threads || []);
     } catch (err) {
-      console.warn('loose-ends fetch failed', err);
-      renderLooseEnds([]);
+      console.warn('open-threads fetch failed', err);
+      renderOpenThreads([]);
     }
   }
-  function renderLooseEnds(threads) {
-    const root = $('loose-ends-section');
-    const list = $('loose-ends-list');
-    const summary = $('loose-ends-summary');
+  function renderOpenThreads(threads) {
+    const root = $('open-threads-section');
+    const list = $('open-threads-list');
+    const summary = $('open-threads-summary');
     if (!root || !list || !summary) return;
     if (!threads.length) {
       root.hidden = true;
-      lastLooseEndsCount = 0;
+      lastOpenThreadsCount = 0;
       return;
     }
     root.hidden = false;
-    summary.textContent = 'loose ends · ' + threads.length;
+    summary.textContent = 'open threads · ' + threads.length;
     list.innerHTML = '';
     // Auto-expand on first appearance of any open thread so the
     // operator notices new loose ends; collapse only on operator
     // click (sticky after that).
-    if (lastLooseEndsCount === 0) root.open = true;
-    lastLooseEndsCount = threads.length;
+    if (lastOpenThreadsCount === 0) root.open = true;
+    lastOpenThreadsCount = threads.length;
     const fmtAge = (s) => {
       if (s < 60) return s + 's';
       if (s < 3600) return Math.floor(s / 60) + 'm';
@@ -455,18 +455,6 @@
           el('span', { class: 'inbox-ts' }, fmtAge(t.age_seconds || 0) + ' ago'),
           el('div', { class: 'inbox-body' }, t.question || ''),
         );
-      } else if (t.kind === 'reminder') {
-        // due_at is an absolute unix-seconds value; show time-until-fire
-        // (negative when overdue, fmtAge handles 0/positive case here).
-        const now = Math.floor(Date.now() / 1000);
-        const dueIn = (t.due_at || 0) - now;
-        const dueLabel = dueIn >= 0 ? 'in ' + fmtAge(dueIn) : fmtAge(-dueIn) + ' overdue';
-        li.append(
-          el('span', { class: 'inbox-from' }, '⏰ reminder #' + t.id), ' ',
-          el('span', { class: 'inbox-sep' }, t.owner + ' · due ' + dueLabel), ' ',
-          el('span', { class: 'inbox-ts' }, 'scheduled ' + fmtAge(t.age_seconds || 0) + ' ago'),
-          el('div', { class: 'inbox-body' }, t.message || ''),
-        );
       } else {
         li.append(el('span', { class: 'inbox-body' }, JSON.stringify(t)));
       }
@@ -626,7 +614,7 @@
       // Open-threads aren't part of /api/state (kept on the broker
       // db, fetched via the per-agent socket). Cold-load fetches
       // it here; turn_end refreshes it via the renderer below.
-      refreshLooseEnds();
+      refreshOpenThreads();
       // Skip the re-render if nothing structurally changed. The most
       // common case is `online` polling itself — without this guard, the
       // operator's <input value> gets clobbered every cycle.
@@ -968,7 +956,7 @@
           } else {
             setBannerActive(false); setState('idle');
             // Likely answered/asked/scheduled something — refresh.
-            refreshLooseEnds();
+            refreshOpenThreads();
           }
           const cls = ev.ok ? 'turn-end-ok' : 'turn-end-fail';
           api.row(cls,
diff --git a/hive-ag3nt/assets/index.html b/hive-ag3nt/assets/index.html
index 7e8dac86..8635a329 100644
--- a/hive-ag3nt/assets/index.html
+++ b/hive-ag3nt/assets/index.html
@@ -29,9 +29,9 @@
     <ul id="inbox-list"></ul>
   </details>
 
-  <details id="loose-ends-section" class="agent-inbox" hidden>
-    <summary>▸ <span id="loose-ends-summary">loose ends</span></summary>
-    <ul id="loose-ends-list"></ul>
+  <details id="open-threads-section" class="agent-inbox" hidden>
+    <summary>▸ <span id="open-threads-summary">open threads</span></summary>
+    <ul id="open-threads-list"></ul>
   </details>
 
   <div class="terminal-wrap">
diff --git a/hive-ag3nt/prompts/agent.md b/hive-ag3nt/prompts/agent.md
index 0b14eae7..25757155 100644
--- a/hive-ag3nt/prompts/agent.md
+++ b/hive-ag3nt/prompts/agent.md
@@ -7,8 +7,7 @@ Tools (hyperhive surface):
 - (some agents only) **extra MCP tools** surfaced as `mcp__<server>__<tool>` — these are agent-specific (matrix client, scraper, db connector, etc.) declared in your `agent.nix` under `hyperhive.extraMcpServers`. Treat them as first-class tools alongside the hyperhive surface; the operator already auto-approved them at deploy time.
 - `mcp__hyperhive__ask(question, options?, multi?, ttl_seconds?, to?)` — surface a structured question to the human operator (default, or `to: "operator"`) OR a peer agent (`to: "<agent-name>"`). Returns immediately with a question id — do NOT wait inline. When the recipient answers, a system message with event `question_answered { id, question, answer, answerer }` lands in your inbox; handle it on a future turn. Use this for clarifications, permission for risky actions, choice between options, or peer Q&A without burning regular inbox slots. `options` is advisory: a short fixed-choice list when applicable, otherwise leave empty for free text. `multi: true` lets the answerer pick multiple (checkboxes), answer comes back comma-joined. `ttl_seconds` auto-cancels with answer `[expired]` (and `answerer: "ttl-watchdog"`) when the decision becomes moot.
 - `mcp__hyperhive__answer(id, answer)` — answer a question that was routed to YOU. You'll see one in your inbox as a `question_asked { id, asker, question, options, multi }` system event when a peer or the manager calls `ask(to: "<your-name>", ...)`. The answer surfaces in the asker's inbox as a `question_answered` event. Strict authorisation: you can only answer questions where you are the declared target.
-- `mcp__hyperhive__get_loose_ends()` — list your loose ends: unanswered questions where you're asker (waiting on someone) or target (owing a reply), plus reminders you've scheduled that haven't fired. No args, cheap server-side sweep. Useful at turn start to remember what's outstanding without scanning inbox archaeology.
-- `mcp__hyperhive__cancel_loose_end(kind, id)` — cancel one of your own open threads. `kind` is `"question"` (the asker — you, in this case — gets a `[cancelled by <you>]` answer so the waiter unblocks) or `"reminder"` (hard-deleted before it fires). `id` from the matching `get_loose_ends` row or the original submission reply.
+- `mcp__hyperhive__get_open_threads()` — list your loose ends: unanswered questions where you're asker (waiting on someone) or target (owing a reply). No args, cheap server-side sweep. Useful at turn start to remember what's outstanding without scanning inbox archaeology.
 - `mcp__hyperhive__whoami()` — self-introspection: returns your canonical agent name (from socket identity, not the prompt-substituted label), role, and current hyperhive rev. No args. Use it when you want a trustworthy identity stamp for state files, commit messages, or cross-agent attribution that won't drift across renames.
 
 Need new packages, env vars, or other NixOS config for yourself? You can't edit your own config directly — message the manager (recipient `manager`) describing what you need + why. The manager evaluates the request (it doesn't rubber-stamp), edits `/agents/{label}/config/agent.nix` on your behalf, commits, and submits an approval that the operator can accept on the dashboard; on approve hive-c0re rebuilds your container with the new config.
diff --git a/hive-ag3nt/prompts/manager.md b/hive-ag3nt/prompts/manager.md
index 6f6cf952..9990922d 100644
--- a/hive-ag3nt/prompts/manager.md
+++ b/hive-ag3nt/prompts/manager.md
@@ -12,8 +12,7 @@ Tools (hyperhive surface):
 - `mcp__hyperhive__request_apply_commit(agent, commit_ref, description?)` — submit a config change for any agent (`hm1nd` for self) for operator approval. Pass an optional `description` and it appears on the dashboard approval card so the operator knows what changed without opening the diff. At submit time hive-c0re fetches your commit into the agent's applied repo and pins it as `proposal/<id>`; from that moment your proposed-side commit can be amended or force-pushed freely without changing what the operator will build.
 - `mcp__hyperhive__ask(question, options?, multi?, ttl_seconds?, to?)` — surface a structured question to the operator (default, or `to: "operator"`) OR a sub-agent (`to: "<agent-name>"`). Returns immediately with a question id; the answer arrives later as a system `question_answered { id, question, answer, answerer }` event in your inbox. Options are advisory: the dashboard always lets the operator type a free-text answer in addition. Set `multi: true` to render options as checkboxes (operator can pick multiple); the answer comes back as `, `-separated. Set `ttl_seconds` to auto-cancel after a deadline (capped at 6h server-side) — on expiry the answer is `[expired]` and `answerer` is `"ttl-watchdog"`. Do not poll inside the same turn — finish the current work and react when the event lands.
 - `mcp__hyperhive__answer(id, answer)` — answer a question that was routed to YOU (a sub-agent did `ask(to: "manager", ...)`). The triggering event in your inbox is `question_asked { id, asker, question, options, multi }`. The answer surfaces in the asker's inbox as a `question_answered` event.
-- `mcp__hyperhive__get_loose_ends()` — hive-wide loose ends: every pending approval + every unanswered question + every pending reminder across the swarm. Cheap server-side sweep, no args. Use to find stalled threads (sub-agent A asked B something three days ago and B never answered) before they rot.
-- `mcp__hyperhive__cancel_loose_end(kind, id)` — cancel any question or reminder in the swarm (manager bypasses the owner check used on sub-agents). Use for hive-wide cleanup when a sub-agent is offline / can't withdraw its own ask / reminder.
+- `mcp__hyperhive__get_open_threads()` — hive-wide loose ends: every pending approval + every unanswered question across the swarm. Cheap server-side sweep, no args. Use to find stalled threads (sub-agent A asked B something three days ago and B never answered) before they rot.
 - `mcp__hyperhive__whoami()` — self-introspection: canonical name (`manager`), role, current hyperhive rev. No args. Useful for boot announcements and cross-agent attribution that won't drift across config reloads.
 
 Approval boundary: lifecycle ops on *existing* sub-agents (`kill`, `start`, `restart`) are at your discretion — no operator approval. *Creating* a new agent (`request_spawn`) and *changing* any agent's config (`request_apply_commit`) still go through the approval queue. The operator only signs off on changes; you run the day-to-day.
diff --git a/hive-ag3nt/src/bin/hive-ag3nt.rs b/hive-ag3nt/src/bin/hive-ag3nt.rs
index 03cce241..689df58d 100644
--- a/hive-ag3nt/src/bin/hive-ag3nt.rs
+++ b/hive-ag3nt/src/bin/hive-ag3nt.rs
@@ -240,7 +240,7 @@ async fn serve(
                 | AgentResponse::Status { .. }
                 | AgentResponse::Recent { .. }
                 | AgentResponse::QuestionQueued { .. }
-                | AgentResponse::LooseEnds { .. }
+                | AgentResponse::OpenThreads { .. }
                 | AgentResponse::PendingRemindersCount { .. }
                 | AgentResponse::Whoami { .. },
             ) => {
@@ -320,11 +320,11 @@ fn now_unix() -> i64 {
 async fn fetch_agent_post_turn_counts(socket: &Path) -> (Option<u64>, Option<u64>) {
     let threads = match client::request::<_, AgentResponse>(
         socket,
-        &AgentRequest::GetLooseEnds,
+        &AgentRequest::GetOpenThreads,
     )
     .await
     {
-        Ok(AgentResponse::LooseEnds { loose_ends }) => u64::try_from(loose_ends.len()).ok(),
+        Ok(AgentResponse::OpenThreads { threads }) => u64::try_from(threads.len()).ok(),
         _ => None,
     };
     let reminders = match client::request::<_, AgentResponse>(
diff --git a/hive-ag3nt/src/bin/hive-m1nd.rs b/hive-ag3nt/src/bin/hive-m1nd.rs
index 870b41f4..89bcb8ba 100644
--- a/hive-ag3nt/src/bin/hive-m1nd.rs
+++ b/hive-ag3nt/src/bin/hive-m1nd.rs
@@ -208,7 +208,7 @@ async fn serve(
                 | ManagerResponse::QuestionQueued { .. }
                 | ManagerResponse::Recent { .. }
                 | ManagerResponse::Logs { .. }
-                | ManagerResponse::LooseEnds { .. }
+                | ManagerResponse::OpenThreads { .. }
                 | ManagerResponse::PendingRemindersCount { .. }
                 | ManagerResponse::Whoami { .. },
             ) => {
@@ -259,11 +259,11 @@ fn now_unix() -> i64 {
 async fn fetch_manager_post_turn_counts(socket: &Path) -> (Option<u64>, Option<u64>) {
     let threads = match client::request::<_, ManagerResponse>(
         socket,
-        &ManagerRequest::GetLooseEnds,
+        &ManagerRequest::GetOpenThreads,
     )
     .await
     {
-        Ok(ManagerResponse::LooseEnds { loose_ends }) => u64::try_from(loose_ends.len()).ok(),
+        Ok(ManagerResponse::OpenThreads { threads }) => u64::try_from(threads.len()).ok(),
         _ => None,
     };
     let reminders = match client::request::<_, ManagerResponse>(
diff --git a/hive-ag3nt/src/mcp.rs b/hive-ag3nt/src/mcp.rs
index 774fd6fd..7bd87af9 100644
--- a/hive-ag3nt/src/mcp.rs
+++ b/hive-ag3nt/src/mcp.rs
@@ -40,7 +40,7 @@ pub enum SocketReply {
     QuestionQueued(i64),
     Recent(Vec<hive_sh4re::InboxRow>),
     Logs(String),
-    LooseEnds(Vec<hive_sh4re::LooseEnd>),
+    OpenThreads(Vec<hive_sh4re::OpenThread>),
     PendingRemindersCount(u64),
     Whoami {
         name: String,
@@ -59,7 +59,7 @@ impl From<hive_sh4re::AgentResponse> for SocketReply {
             hive_sh4re::AgentResponse::Status { unread } => Self::Status(unread),
             hive_sh4re::AgentResponse::Recent { rows } => Self::Recent(rows),
             hive_sh4re::AgentResponse::QuestionQueued { id } => Self::QuestionQueued(id),
-            hive_sh4re::AgentResponse::LooseEnds { loose_ends } => Self::LooseEnds(loose_ends),
+            hive_sh4re::AgentResponse::OpenThreads { threads } => Self::OpenThreads(threads),
             hive_sh4re::AgentResponse::PendingRemindersCount { count } => {
                 Self::PendingRemindersCount(count)
             }
@@ -87,7 +87,7 @@ impl From<hive_sh4re::ManagerResponse> for SocketReply {
             hive_sh4re::ManagerResponse::QuestionQueued { id } => Self::QuestionQueued(id),
             hive_sh4re::ManagerResponse::Recent { rows } => Self::Recent(rows),
             hive_sh4re::ManagerResponse::Logs { content } => Self::Logs(content),
-            hive_sh4re::ManagerResponse::LooseEnds { loose_ends } => Self::LooseEnds(loose_ends),
+            hive_sh4re::ManagerResponse::OpenThreads { threads } => Self::OpenThreads(threads),
             hive_sh4re::ManagerResponse::PendingRemindersCount { count } => {
                 Self::PendingRemindersCount(count)
             }
@@ -128,16 +128,16 @@ pub fn format_recv(resp: Result<SocketReply, anyhow::Error>) -> String {
     }
 }
 
-/// Format helper for `get_loose_ends`: renders a short bulleted list
+/// Format helper for `get_open_threads`: renders a short bulleted list
 /// of pending approvals + questions. Empty list collapses to a clear
 /// marker so claude doesn't go hunting for a payload that isn't there.
-pub fn format_loose_ends(resp: Result<SocketReply, anyhow::Error>) -> String {
+pub fn format_open_threads(resp: Result<SocketReply, anyhow::Error>) -> String {
     use std::fmt::Write as _;
     let threads = match resp {
-        Ok(SocketReply::LooseEnds(t)) => t,
-        Ok(SocketReply::Err(m)) => return format!("get_loose_ends failed: {m}"),
-        Ok(other) => return format!("get_loose_ends unexpected response: {other:?}"),
-        Err(e) => return format!("get_loose_ends transport error: {e:#}"),
+        Ok(SocketReply::OpenThreads(t)) => t,
+        Ok(SocketReply::Err(m)) => return format!("get_open_threads failed: {m}"),
+        Ok(other) => return format!("get_open_threads unexpected response: {other:?}"),
+        Err(e) => return format!("get_open_threads transport error: {e:#}"),
     };
     if threads.is_empty() {
         return "(no open threads)".to_owned();
@@ -145,7 +145,7 @@ pub fn format_loose_ends(resp: Result<SocketReply, anyhow::Error>) -> String {
     let mut out = format!("{} open thread(s):\n", threads.len());
     for t in &threads {
         match t {
-            hive_sh4re::LooseEnd::Approval {
+            hive_sh4re::OpenThread::Approval {
                 id,
                 agent,
                 commit_ref,
@@ -161,7 +161,7 @@ pub fn format_loose_ends(resp: Result<SocketReply, anyhow::Error>) -> String {
                     "- approval #{id} ({agent} @ {commit_ref}, {age_seconds}s old){desc}"
                 );
             }
-            hive_sh4re::LooseEnd::Question {
+            hive_sh4re::OpenThread::Question {
                 id,
                 asker,
                 target,
@@ -174,37 +174,11 @@ pub fn format_loose_ends(resp: Result<SocketReply, anyhow::Error>) -> String {
                     "- question #{id} ({asker} → {to}, {age_seconds}s old): {question}"
                 );
             }
-            hive_sh4re::LooseEnd::Reminder {
-                id,
-                owner,
-                message,
-                due_at,
-                age_seconds,
-            } => {
-                let _ = writeln!(
-                    out,
-                    "- reminder #{id} ({owner}, scheduled {age_seconds}s ago, due_at={due_at}): {message}"
-                );
-            }
         }
     }
     out
 }
 
-/// Parse the user-facing `kind` string for `cancel_loose_end` into the
-/// wire enum. Accepts a small alias set so claude doesn't have to
-/// remember the exact spelling (`"q"` / `"r"` shorthand falls out
-/// for free).
-fn parse_loose_end_kind(raw: &str) -> Result<hive_sh4re::CancelLooseEndKind, String> {
-    match raw.trim().to_ascii_lowercase().as_str() {
-        "question" | "q" => Ok(hive_sh4re::CancelLooseEndKind::Question),
-        "reminder" | "r" => Ok(hive_sh4re::CancelLooseEndKind::Reminder),
-        other => Err(format!(
-            "cancel_loose_end: unknown kind '{other}' (expected \"question\" or \"reminder\")"
-        )),
-    }
-}
-
 /// Format helper for `whoami`: renders the identity block as a short
 /// human-readable string. Skips fields that are `None` so the output
 /// doesn't carry dead placeholders.
@@ -449,18 +423,16 @@ impl AgentServer {
     #[tool(
         description = "List loose ends pending against this agent: unanswered questions \
         where you are the asker (waiting on someone) or the target (someone's waiting on \
-        you), pending reminders you scheduled, plus — for the manager only — pending \
-        approvals you submitted that the operator hasn't acted on yet. Cheap server-side \
-        sweep, no args. Useful at turn start to remember what you owe / what's owed to \
-        you without scrolling inbox history. Output is a short bulleted list with ids, \
-        ages in seconds, and the relevant context. Each `question` or `reminder` row \
-        can be cancelled by passing its id + kind to `cancel_loose_end`. Empty result \
-        is reported clearly."
+        you), plus — for the manager only — pending approvals you submitted that the \
+        operator hasn't acted on yet. Cheap server-side sweep, no args. Useful at turn \
+        start to remember what you owe / what's owed to you without scrolling inbox \
+        history. Output is a short bulleted list with ids, ages in seconds, and the \
+        relevant context. Empty result is reported clearly."
     )]
-    async fn get_loose_ends(&self) -> String {
-        run_tool_envelope("get_loose_ends", String::new(), async move {
-            let (resp, retries) = self.dispatch(hive_sh4re::AgentRequest::GetLooseEnds).await;
-            annotate_retries(format_loose_ends(resp), retries)
+    async fn get_open_threads(&self) -> String {
+        run_tool_envelope("get_open_threads", String::new(), async move {
+            let (resp, retries) = self.dispatch(hive_sh4re::AgentRequest::GetOpenThreads).await;
+            annotate_retries(format_open_threads(resp), retries)
         })
         .await
     }
@@ -481,34 +453,6 @@ impl AgentServer {
         .await
     }
 
-    #[tool(
-        description = "Cancel an open thread you own — a `question` you asked (the \
-        asker gets `[cancelled by <you>]` as the answer and unblocks) or a `reminder` \
-        you scheduled (hard-deleted before it fires). `kind` is `\"question\"` or \
-        `\"reminder\"`; `id` is the row id from the matching `get_loose_ends` entry \
-        or the `question_queued` reply you got when you submitted. Auth: you can only \
-        cancel rows where you're the asker / owner. Returns `ok` or an error string."
-    )]
-    async fn cancel_loose_end(&self, Parameters(args): Parameters<CancelLooseEndArgs>) -> String {
-        let log = format!("{args:?}");
-        let kind_label = args.kind.clone();
-        let id = args.id;
-        run_tool_envelope("cancel_loose_end", log, async move {
-            let kind = match parse_loose_end_kind(&args.kind) {
-                Ok(k) => k,
-                Err(e) => return e,
-            };
-            let (resp, retries) = self
-                .dispatch(hive_sh4re::AgentRequest::CancelLooseEnd { kind, id })
-                .await;
-            annotate_retries(
-                format_ack(resp, "cancel_loose_end", format!("cancelled {kind_label} {id}")),
-                retries,
-            )
-        })
-        .await
-    }
-
     #[tool(
         description = "Schedule a reminder that lands in this agent's own inbox at a future \
         time (sender will appear as `reminder`). Use for self-paced follow-ups: 'check task \
@@ -653,18 +597,6 @@ pub struct AnswerArgs {
     pub answer: String,
 }
 
-#[derive(Debug, serde::Deserialize, schemars::JsonSchema)]
-pub struct CancelLooseEndArgs {
-    /// Which kind of thread to cancel — `"question"` for an open
-    /// `ask` that's still waiting on an answer, `"reminder"` for a
-    /// scheduled `remind` that hasn't fired yet. Use the `kind`
-    /// field straight off the `get_loose_ends` row.
-    pub kind: String,
-    /// Row id from the matching `get_loose_ends` entry (or the
-    /// `question_queued` reply when you submitted it).
-    pub id: i64,
-}
-
 #[derive(Debug, serde::Deserialize, schemars::JsonSchema)]
 pub struct RequestApplyCommitArgs {
     /// Agent whose config repo the commit lives in (use `"hm1nd"` for the
@@ -990,19 +922,17 @@ impl ManagerServer {
 
     #[tool(
         description = "Hive-wide loose ends: EVERY pending approval + EVERY unanswered \
-        question + EVERY pending reminder across the swarm. Use to scan for stalled \
-        coordination — questions sub-agents asked each other that nobody's answering, \
-        approvals stuck waiting on the operator, reminders piling up on an offline \
-        agent, etc. No args. The sub-agent flavour only returns the agent's own \
-        threads; the manager flavour is unfiltered. Cancel any question or reminder \
-        row via `cancel_loose_end` (manager bypasses the owner check)."
+        question across the swarm. Use to scan for stalled coordination — questions \
+        sub-agents asked each other that nobody's answering, approvals stuck waiting on \
+        the operator, etc. No args. The sub-agent flavour of this tool only returns the \
+        agent's own threads; the manager flavour is unfiltered."
     )]
-    async fn get_loose_ends(&self) -> String {
-        run_tool_envelope("get_loose_ends", String::new(), async move {
+    async fn get_open_threads(&self) -> String {
+        run_tool_envelope("get_open_threads", String::new(), async move {
             let (resp, retries) = self
-                .dispatch(hive_sh4re::ManagerRequest::GetLooseEnds)
+                .dispatch(hive_sh4re::ManagerRequest::GetOpenThreads)
                 .await;
-            annotate_retries(format_loose_ends(resp), retries)
+            annotate_retries(format_open_threads(resp), retries)
         })
         .await
     }
@@ -1021,34 +951,6 @@ impl ManagerServer {
         .await
     }
 
-    #[tool(
-        description = "Cancel any open thread in the swarm — a `question` (cancels \
-        with the operator-override sentinel so the asker unblocks) or a `reminder` \
-        (hard-deleted before fire). `kind` is `\"question\"` or `\"reminder\"`; `id` \
-        is the row id from `get_loose_ends` or the original submission reply. \
-        Manager surface bypasses the owner check on the sub-agent flavour — use for \
-        hive-wide cleanup of stuck or stale threads."
-    )]
-    async fn cancel_loose_end(&self, Parameters(args): Parameters<CancelLooseEndArgs>) -> String {
-        let log = format!("{args:?}");
-        let kind_label = args.kind.clone();
-        let id = args.id;
-        run_tool_envelope("cancel_loose_end", log, async move {
-            let kind = match parse_loose_end_kind(&args.kind) {
-                Ok(k) => k,
-                Err(e) => return e,
-            };
-            let (resp, retries) = self
-                .dispatch(hive_sh4re::ManagerRequest::CancelLooseEnd { kind, id })
-                .await;
-            annotate_retries(
-                format_ack(resp, "cancel_loose_end", format!("cancelled {kind_label} {id}")),
-                retries,
-            )
-        })
-        .await
-    }
-
     #[tool(
         description = "Fetch recent journal log lines for a sub-agent container. Useful \
         for diagnosing MCP server registration failures, startup crashes, plugin install \
@@ -1092,10 +994,9 @@ impl ManagerServer {
         any agent including yourself), `ask` (structured question to the operator or a \
         sub-agent — non-blocking, answer arrives later as a `question_answered` event), \
         `answer` (respond to a `question_asked` event directed at you), \
-        `get_loose_ends` (hive-wide loose ends — pending approvals + unanswered \
-        questions + pending reminders across the swarm), `cancel_loose_end` (cancel any \
-        question or reminder row by id), `whoami` (self-introspection — canonical \
-        name, role, current hyperhive rev). The manager's own config lives at \
+        `get_open_threads` (hive-wide loose ends — pending approvals + unanswered \
+        questions across the swarm), `whoami` (self-introspection — canonical name, \
+        role, current hyperhive rev). The manager's own config lives at \
         `/agents/hm1nd/config/agent.nix`."
 )]
 impl ServerHandler for ManagerServer {}
@@ -1136,9 +1037,8 @@ pub fn allowed_mcp_tools(flavor: Flavor) -> Vec<String> {
             "ask",
             "answer",
             "remind",
-            "get_loose_ends",
+            "get_open_threads",
             "whoami",
-            "cancel_loose_end",
         ],
         Flavor::Manager => &[
             "send",
@@ -1152,10 +1052,9 @@ pub fn allowed_mcp_tools(flavor: Flavor) -> Vec<String> {
             "ask",
             "answer",
             "get_logs",
-            "get_loose_ends",
+            "get_open_threads",
             "remind",
             "whoami",
-            "cancel_loose_end",
         ],
     };
     let mut out: Vec<String> = names
diff --git a/hive-ag3nt/src/web_ui.rs b/hive-ag3nt/src/web_ui.rs
index fbf4d5df..82d9b62c 100644
--- a/hive-ag3nt/src/web_ui.rs
+++ b/hive-ag3nt/src/web_ui.rs
@@ -106,7 +106,7 @@ pub async fn serve(
         .route("/api/compact", post(post_compact))
         .route("/api/model", post(post_set_model))
         .route("/api/new-session", post(post_new_session))
-        .route("/api/loose-ends", get(api_loose_ends))
+        .route("/api/open-threads", get(api_open_threads))
         .with_state(state);
     let addr = SocketAddr::from(([0, 0, 0, 0], port));
     let listener = bind_with_retry(addr, "web UI").await?;
@@ -240,25 +240,25 @@ struct SessionView {
     exit_note: Option<String>,
 }
 
-/// Proxy this agent's loose-ends list via the per-agent socket. The
+/// Proxy this agent's open-threads via the per-agent socket. The
 /// web UI surfaces the result as a collapsible section in the page
 /// so the operator can see at a glance what's pending against the
 /// agent (questions asked by it, peer questions targeting it,
-/// reminders it scheduled, approvals for the manager). Same data
-/// the `mcp__hyperhive__get_loose_ends` tool sees from inside the
+/// approvals for the manager). Same data the
+/// `mcp__hyperhive__get_open_threads` tool sees from inside the
 /// container.
-async fn api_loose_ends(State(state): State<AppState>) -> Response {
-    let loose_ends: Vec<hive_sh4re::LooseEnd> = match state.flavor() {
+async fn api_open_threads(State(state): State<AppState>) -> Response {
+    let threads: Vec<hive_sh4re::OpenThread> = match state.flavor() {
         Flavor::Agent => {
             match client::request::<_, hive_sh4re::AgentResponse>(
                 &state.socket,
-                &hive_sh4re::AgentRequest::GetLooseEnds,
+                &hive_sh4re::AgentRequest::GetOpenThreads,
             )
             .await
             {
-                Ok(hive_sh4re::AgentResponse::LooseEnds { loose_ends }) => loose_ends,
+                Ok(hive_sh4re::AgentResponse::OpenThreads { threads }) => threads,
                 Ok(hive_sh4re::AgentResponse::Err { message }) => {
-                    return error_response(&format!("get_loose_ends: {message}"));
+                    return error_response(&format!("get_open_threads: {message}"));
                 }
                 Ok(other) => return error_response(&format!("unexpected response: {other:?}")),
                 Err(e) => return error_response(&format!("transport: {e:#}")),
@@ -267,20 +267,20 @@ async fn api_loose_ends(State(state): State<AppState>) -> Response {
         Flavor::Manager => {
             match client::request::<_, hive_sh4re::ManagerResponse>(
                 &state.socket,
-                &hive_sh4re::ManagerRequest::GetLooseEnds,
+                &hive_sh4re::ManagerRequest::GetOpenThreads,
             )
             .await
             {
-                Ok(hive_sh4re::ManagerResponse::LooseEnds { loose_ends }) => loose_ends,
+                Ok(hive_sh4re::ManagerResponse::OpenThreads { threads }) => threads,
                 Ok(hive_sh4re::ManagerResponse::Err { message }) => {
-                    return error_response(&format!("get_loose_ends: {message}"));
+                    return error_response(&format!("get_open_threads: {message}"));
                 }
                 Ok(other) => return error_response(&format!("unexpected response: {other:?}")),
                 Err(e) => return error_response(&format!("transport: {e:#}")),
             }
         }
     };
-    axum::Json(serde_json::json!({ "loose_ends": loose_ends })).into_response()
+    axum::Json(serde_json::json!({ "threads": threads })).into_response()
 }
 
 async fn api_state(State(state): State<AppState>) -> axum::Json<StateSnapshot> {
diff --git a/hive-c0re/src/agent_server.rs b/hive-c0re/src/agent_server.rs
index 8615f165..311e8560 100644
--- a/hive-c0re/src/agent_server.rs
+++ b/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::GetLooseEnds => match crate::loose_ends::for_agent(coord, agent) {
-            Ok(loose_ends) => AgentResponse::LooseEnds { loose_ends },
+        AgentRequest::GetOpenThreads => match crate::open_threads::for_agent(coord, agent) {
+            Ok(threads) => AgentResponse::OpenThreads { threads },
             Err(e) => AgentResponse::Err {
                 message: format!("{e:#}"),
             },
@@ -193,13 +193,6 @@ 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::CancelLooseEnd { kind, id } => crate::questions::handle_cancel_loose_end(
-            coord, agent, *kind, *id,
-        )
-        .map_or_else(
-            |message| AgentResponse::Err { message },
-            |()| AgentResponse::Ok,
-        ),
     }
 }
 
diff --git a/hive-c0re/src/broker.rs b/hive-c0re/src/broker.rs
index e29c21fc..fbbb2d6d 100644
--- a/hive-c0re/src/broker.rs
+++ b/hive-c0re/src/broker.rs
@@ -405,40 +405,6 @@ impl Broker {
         Ok(n)
     }
 
-    /// Cancel a pending reminder on behalf of `canceller`. Returns
-    /// the owner agent name on success (handy for logging). Auth
-    /// rules mirror `OperatorQuestions::cancel`: owner, operator, or
-    /// manager.
-    pub fn cancel_reminder_as(&self, id: i64, canceller: &str) -> Result<String> {
-        let conn = self.conn.lock().unwrap();
-        let owner: Option<String> = conn
-            .query_row(
-                "SELECT agent FROM reminders WHERE id = ?1 AND sent_at IS NULL",
-                params![id],
-                |row| row.get(0),
-            )
-            .optional()?;
-        let Some(owner) = owner else {
-            anyhow::bail!("reminder {id} not pending (already delivered or unknown)");
-        };
-        let authorised = canceller == owner
-            || canceller == hive_sh4re::OPERATOR_RECIPIENT
-            || canceller == hive_sh4re::MANAGER_AGENT;
-        if !authorised {
-            anyhow::bail!(
-                "reminder {id}: '{canceller}' not allowed to cancel (owner = '{owner}')"
-            );
-        }
-        let n = conn.execute(
-            "DELETE FROM reminders WHERE id = ?1 AND sent_at IS NULL",
-            params![id],
-        )?;
-        if n == 0 {
-            anyhow::bail!("reminder {id} vanished between auth check and delete");
-        }
-        Ok(owner)
-    }
-
     /// Get up to `limit` due reminders across all agents in a single query.
     /// Returns `(agent, id, message, file_path)` tuples. Pass a small limit
     /// (e.g. 100) so a burst of overdue reminders doesn't flood the broker
diff --git a/hive-c0re/src/main.rs b/hive-c0re/src/main.rs
index edd6e051..052d6470 100644
--- a/hive-c0re/src/main.rs
+++ b/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;
diff --git a/hive-c0re/src/manager_server.rs b/hive-c0re/src/manager_server.rs
index c6e7aa59..96634543 100644
--- a/hive-c0re/src/manager_server.rs
+++ b/hive-c0re/src/manager_server.rs
@@ -329,8 +329,8 @@ async fn dispatch(req: &ManagerRequest, coord: &Arc<Coordinator>) -> ManagerResp
                 },
             }
         }
-        ManagerRequest::GetLooseEnds => match crate::loose_ends::hive_wide(coord) {
-            Ok(loose_ends) => ManagerResponse::LooseEnds { loose_ends },
+        ManagerRequest::GetOpenThreads => match crate::open_threads::hive_wide(coord) {
+            Ok(threads) => ManagerResponse::OpenThreads { threads },
             Err(e) => ManagerResponse::Err {
                 message: format!("{e:#}"),
             },
@@ -348,16 +348,6 @@ 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::CancelLooseEnd { kind, id } => crate::questions::handle_cancel_loose_end(
-            coord,
-            MANAGER_AGENT,
-            *kind,
-            *id,
-        )
-        .map_or_else(
-            |message| ManagerResponse::Err { message },
-            |()| ManagerResponse::Ok,
-        ),
     }
 }
 
diff --git a/hive-c0re/src/loose_ends.rs b/hive-c0re/src/open_threads.rs
similarity index 71%
rename from hive-c0re/src/loose_ends.rs
rename to hive-c0re/src/open_threads.rs
index 6cd903de..0342414a 100644
--- a/hive-c0re/src/loose_ends.rs
+++ b/hive-c0re/src/open_threads.rs
@@ -1,7 +1,7 @@
 //! Loose-ends aggregator. Walks the `approvals` + `operator_questions`
-//! tables once per call and assembles a `Vec<LooseEnd>` for either
+//! tables once per call and assembles a `Vec<OpenThread>` for either
 //! a single agent (`for_agent`) or the whole hive (`hive_wide`). Both
-//! `AgentRequest::GetLooseEnds` and `ManagerRequest::GetLooseEnds`
+//! `AgentRequest::GetOpenThreads` and `ManagerRequest::GetOpenThreads`
 //! land here so the routing logic + age-seconds derivation stay in
 //! one place.
 //!
@@ -16,7 +16,7 @@
 use std::time::{SystemTime, UNIX_EPOCH};
 
 use anyhow::Result;
-use hive_sh4re::{MANAGER_AGENT, LooseEnd};
+use hive_sh4re::{MANAGER_AGENT, OpenThread};
 
 use crate::coordinator::Coordinator;
 
@@ -26,13 +26,10 @@ use crate::coordinator::Coordinator;
 ///   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`).
+///   someone) OR the target (owes a reply).
 ///
-/// 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>> {
+/// Newest-first within each kind, approvals before questions.
+pub fn for_agent(coord: &Coordinator, agent: &str) -> Result<Vec<OpenThread>> {
     let now = now_unix();
     let mut out = Vec::new();
     // Approvals are only submitted by the manager today. When that
@@ -41,7 +38,7 @@ pub fn for_agent(coord: &Coordinator, agent: &str) -> Result<Vec<LooseEnd>> {
     // here on that column — for now MANAGER_AGENT == sole submitter.
     if agent == MANAGER_AGENT {
         for a in coord.approvals.pending()? {
-            out.push(LooseEnd::Approval {
+            out.push(OpenThread::Approval {
                 id: a.id,
                 agent: a.agent,
                 commit_ref: a.commit_ref,
@@ -55,7 +52,7 @@ pub fn for_agent(coord: &Coordinator, agent: &str) -> Result<Vec<LooseEnd>> {
         if !role_match {
             continue;
         }
-        out.push(LooseEnd::Question {
+        out.push(OpenThread::Question {
             id: q.id,
             asker: q.asker,
             target: q.target,
@@ -63,30 +60,18 @@ pub fn for_agent(coord: &Coordinator, agent: &str) -> Result<Vec<LooseEnd>> {
             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>> {
+/// unanswered question. 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<OpenThread>> {
     let now = now_unix();
     let mut out = Vec::new();
     for a in coord.approvals.pending()? {
-        out.push(LooseEnd::Approval {
+        out.push(OpenThread::Approval {
             id: a.id,
             agent: a.agent,
             commit_ref: a.commit_ref,
@@ -95,7 +80,7 @@ pub fn hive_wide(coord: &Coordinator) -> Result<Vec<LooseEnd>> {
         });
     }
     for q in coord.questions.pending_all()? {
-        out.push(LooseEnd::Question {
+        out.push(OpenThread::Question {
             id: q.id,
             asker: q.asker,
             target: q.target,
@@ -103,15 +88,6 @@ pub fn hive_wide(coord: &Coordinator) -> Result<Vec<LooseEnd>> {
             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)
 }
 
diff --git a/hive-c0re/src/operator_questions.rs b/hive-c0re/src/operator_questions.rs
index ce9a2094..5ef5b199 100644
--- a/hive-c0re/src/operator_questions.rs
+++ b/hive-c0re/src/operator_questions.rs
@@ -196,54 +196,6 @@ impl OperatorQuestions {
         Ok((question, asker, target))
     }
 
-    /// Cancel a pending question on behalf of `canceller`. Returns
-    /// `(question, asker, target)` so the caller can fire the usual
-    /// `QuestionAnswered` event to the asker with a `[cancelled by
-    /// <canceller>]` sentinel.
-    ///
-    /// Auth: the canceller must be one of:
-    /// - the original asker (an agent withdrawing their own ask),
-    /// - the operator (already covered by the existing `answer` path
-    ///   but allowed here too for symmetry / dashboard cancel),
-    /// - the manager (privileged hive-wide cleanup).
-    ///
-    /// Not the target — that's covered by `answer` (responding with
-    /// an actual reply, sentinel or otherwise).
-    pub fn cancel(
-        &self,
-        id: i64,
-        canceller: &str,
-    ) -> Result<(String, String, Option<String>)> {
-        let conn = self.conn.lock().unwrap();
-        let row: Option<(String, String, Option<String>, Option<i64>)> = conn
-            .query_row(
-                "SELECT question, asker, target, answered_at FROM operator_questions WHERE id = ?1",
-                params![id],
-                |row| Ok((row.get(0)?, row.get(1)?, row.get(2)?, row.get(3)?)),
-            )
-            .optional()?;
-        let Some((question, asker, target, answered_at)) = row else {
-            bail!("question {id} not found");
-        };
-        if answered_at.is_some() {
-            bail!("question {id} already answered/cancelled");
-        }
-        let authorised = canceller == asker
-            || canceller == hive_sh4re::OPERATOR_RECIPIENT
-            || canceller == hive_sh4re::MANAGER_AGENT;
-        if !authorised {
-            bail!(
-                "question {id}: '{canceller}' not allowed to cancel (asker = '{asker}')"
-            );
-        }
-        let sentinel = format!("[cancelled by {canceller}]");
-        conn.execute(
-            "UPDATE operator_questions SET answer = ?1, answered_at = ?2 WHERE id = ?3",
-            params![sentinel, now_unix(), id],
-        )?;
-        Ok((question, asker, target))
-    }
-
     #[allow(dead_code)]
     pub fn get(&self, id: i64) -> Result<Option<OpQuestion>> {
         let conn = self.conn.lock().unwrap();
diff --git a/hive-c0re/src/questions.rs b/hive-c0re/src/questions.rs
index 5ff82a9c..d622d1d8 100644
--- a/hive-c0re/src/questions.rs
+++ b/hive-c0re/src/questions.rs
@@ -129,49 +129,6 @@ pub fn handle_answer(
     Ok(())
 }
 
-/// 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_loose_end(
-    coord: &Arc<Coordinator>,
-    canceller: &str,
-    kind: hive_sh4re::CancelLooseEndKind,
-    id: i64,
-) -> Result<(), String> {
-    match kind {
-        hive_sh4re::CancelLooseEndKind::Question => {
-            let (question, asker, target) = coord
-                .questions
-                .cancel(id, canceller)
-                .map_err(|e| format!("{e:#}"))?;
-            let sentinel = format!("[cancelled by {canceller}]");
-            tracing::info!(%id, %canceller, %asker, "question cancelled");
-            coord.notify_agent(
-                &asker,
-                &hive_sh4re::HelperEvent::QuestionAnswered {
-                    id,
-                    question,
-                    answer: sentinel.clone(),
-                    answerer: canceller.to_owned(),
-                },
-            );
-            coord.emit_question_resolved(id, &sentinel, canceller, true, target.as_deref());
-            Ok(())
-        }
-        hive_sh4re::CancelLooseEndKind::Reminder => {
-            let owner = coord
-                .broker
-                .cancel_reminder_as(id, canceller)
-                .map_err(|e| format!("{e:#}"))?;
-            tracing::info!(%id, %canceller, %owner, "reminder cancelled");
-            Ok(())
-        }
-    }
-}
-
 // Real coverage needs a `Coordinator` fixture (broker + sqlite +
 // in-memory questions). Skipped for now — the normalisation branches
 // in `handle_ask` are short enough to read line-by-line; once we add
diff --git a/hive-sh4re/src/lib.rs b/hive-sh4re/src/lib.rs
index 47c84fb3..1984364b 100644
--- a/hive-sh4re/src/lib.rs
+++ b/hive-sh4re/src/lib.rs
@@ -185,21 +185,16 @@ pub enum ReminderTiming {
     At { unix_timestamp: i64 },
 }
 
-/// One row in the response to `GetLooseEnds`. Tagged enum so new
+/// One row in the response to `GetOpenThreads`. Tagged enum so new
 /// thread kinds (forge PRs, long-running approvals from a privileged
 /// bot, etc) can land later without breaking existing handlers. The
 /// caller (claude in the agent harness) is expected to render these
 /// as a short bulleted list — the per-row fields are all the context
 /// needed without a follow-up fetch.
-///
-/// `Question` and `Reminder` rows are cancellable via the
-/// `CancelLooseEnd` request (and the `cancel_loose_end` MCP tool);
-/// `Approval` rows are not (operator approves/denies via the
-/// dashboard, manager has no withdraw path today).
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(tag = "kind", rename_all = "snake_case")]
-pub enum LooseEnd {
-    /// A pending approval. For agent-flavour `GetLooseEnds` calls
+pub enum OpenThread {
+    /// A pending approval. For agent-flavour `GetOpenThreads` calls
     /// this only surfaces when the agent itself is the manager
     /// (sub-agents don't submit approvals). For manager-flavour calls
     /// it lists every pending approval in the swarm. `agent` is the
@@ -228,33 +223,6 @@ pub enum LooseEnd {
         /// Wall-clock seconds since `asked_at`. Saturates at zero.
         age_seconds: u64,
     },
-    /// A scheduled but un-delivered reminder. For agent-flavour calls:
-    /// only the agent's own reminders (where `owner == self`). For
-    /// manager-flavour calls: every pending reminder in the swarm.
-    /// `owner` is the agent who scheduled it; `due_at` is the absolute
-    /// unix timestamp the scheduler is targeting.
-    Reminder {
-        id: i64,
-        owner: String,
-        message: String,
-        due_at: i64,
-        /// Wall-clock seconds since the reminder was scheduled. Saturates
-        /// at zero on clock anomalies. (For time-until-fire, compute
-        /// `due_at - now` client-side from the wire timestamp.)
-        age_seconds: u64,
-    },
-}
-
-/// Kind discriminator for `CancelLooseEnd`. Maps to which underlying
-/// store the dispatcher reaches into (`OperatorQuestions` vs
-/// `Broker::reminders`). Approvals are deliberately not cancellable
-/// — the operator approves/denies via the dashboard, manager has no
-/// withdraw path today.
-#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
-#[serde(rename_all = "snake_case")]
-pub enum CancelLooseEndKind {
-    Question,
-    Reminder,
 }
 
 /// Requests on a per-agent socket. The agent's identity is the socket
@@ -340,7 +308,7 @@ pub enum AgentRequest {
     /// agent submitted them (which only ever happens for the
     /// manager); questions surface where the agent is `asker` or
     /// `target`. Cheap O(n) sweep server-side — no caching.
-    GetLooseEnds,
+    GetOpenThreads,
     /// Count of this agent's pending (un-delivered) reminders. Used
     /// by the harness's per-turn stats sink to snapshot "what was
     /// queued at turn-end time" without paying for a full list.
@@ -351,13 +319,6 @@ pub enum AgentRequest {
     /// identity after a rename or session-continue boundary where the
     /// system-prompt-substituted label is no longer reliable.
     Whoami,
-    /// Cancel an open thread the agent owns: a `Question` they asked
-    /// (returns `[cancelled by <self>]` as the answer to the asker)
-    /// or a `Reminder` they scheduled (hard-deletes the row).
-    /// Authorisation on the sub-agent surface: caller must own the
-    /// row. The manager surface uses the same wire variant but
-    /// accepts any id.
-    CancelLooseEnd { kind: CancelLooseEndKind, id: i64 },
 }
 
 /// Responses on a per-agent socket.
@@ -379,9 +340,9 @@ pub enum AgentResponse {
     /// `Ask` result: the queued question id. The answer lands later
     /// as `HelperEvent::QuestionAnswered` in this agent's inbox.
     QuestionQueued { id: i64 },
-    /// `GetLooseEnds` result: list of loose ends pending against
+    /// `GetOpenThreads` result: list of loose ends pending against
     /// this agent. Ordered newest-first within each kind.
-    LooseEnds { loose_ends: Vec<LooseEnd> },
+    OpenThreads { threads: Vec<OpenThread> },
     /// `CountPendingReminders` result.
     PendingRemindersCount { count: u64 },
     /// `Whoami` result: identity + role + the current hyperhive rev
@@ -655,19 +616,15 @@ pub enum ManagerRequest {
     /// Hive-wide loose-ends view: EVERY pending approval + EVERY
     /// unanswered question in the swarm. Used by the manager to scan
     /// for stalled coordination — the per-agent equivalent on the
-    /// sub-agent surface is `AgentRequest::GetLooseEnds` which
+    /// sub-agent surface is `AgentRequest::GetOpenThreads` which
     /// only returns rows where the agent itself is asker / target.
-    GetLooseEnds,
+    GetOpenThreads,
     /// Count of the manager's own pending reminders. Mirror of
     /// `AgentRequest::CountPendingReminders` on the manager surface.
     CountPendingReminders,
     /// Manager-flavour self-introspection. Same wire shape as
     /// `AgentRequest::Whoami`, but `role` is always `"manager"`.
     Whoami,
-    /// Cancel an open thread (question or reminder). Manager surface
-    /// can cancel any row (no owner check) — same dispatch as
-    /// `AgentRequest::CancelLooseEnd` but with privileged auth.
-    CancelLooseEnd { kind: CancelLooseEndKind, id: i64 },
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -700,11 +657,11 @@ pub enum ManagerResponse {
     Logs {
         content: String,
     },
-    /// `GetLooseEnds` result: hive-wide loose ends (approvals +
-    /// unanswered questions). Same `LooseEnd` variants as the
+    /// `GetOpenThreads` result: hive-wide loose ends (approvals +
+    /// unanswered questions). Same `OpenThread` variants as the
     /// agent surface; the manager's view is unfiltered.
-    LooseEnds {
-        loose_ends: Vec<LooseEnd>,
+    OpenThreads {
+        threads: Vec<OpenThread>,
     },
     /// `CountPendingReminders` result.
     PendingRemindersCount {