cancel_thread: new mcp tool — unify reminder + question cancel on both surfaces

hive-c0re/src/questions.rs

@@ -129,6 +129,49 @@ pub fn handle_answer(
     Ok(())
 }
 
+/// Handle `CancelThread` 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(
+    coord: &Arc<Coordinator>,
+    canceller: &str,
+    kind: hive_sh4re::CancelThreadKind,
+    id: i64,
+) -> Result<(), String> {
+    match kind {
+        hive_sh4re::CancelThreadKind::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::CancelThreadKind::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