feat(#1137): rich unread summary in loose ends and wake signal

- hive-sh4re: UnreadMatrix gains summary: String field (per-room breakdown)
- hive-matrix-mcp/protocol: add RoomUnread struct + UnreadSummary request
- hive-matrix-mcp/handlers: collect_unread() fetches per-room data;
  single-unread rooms include truncated last-message body + sender;
  multi-unread rooms carry count only
- hive-matrix-mcp/wake: format_unread_summary() builds wake body from
  RoomUnread slice; terse one-liner for single-room/single-message,
  bulleted list for multi-room; always appends read-hint
- hive-matrix-mcp/timeline: wake body now covers all rooms with unread
  at fire time, not just the triggering event; falls back to per-event
  teaser if notification counts haven't updated yet
- hive-ag3nt/mcp: matrix_unread_summary() replaces matrix_unread_rooms();
  UnreadMatrix loose end carries per-room summary lines; render shows
  room breakdown with sender: body for single-unread rooms

hive-matrix-mcp/src/handlers.rs

@@ -357,3 +357,73 @@ pub fn unread_count(client: &Client) -> DaemonResponse {
         .count() as u32;
     DaemonResponse::ok(&serde_json::json!({ "rooms": rooms }))
 }
+
+/// Collect all rooms with unread notifications and build per-room
+/// [`crate::protocol::RoomUnread`] entries. For rooms with exactly
+/// one unread notification the last message body is fetched via the
+/// `/messages` endpoint (best-effort; failures leave `last_body` as
+/// `None`). Rooms with zero unreads are omitted.
+pub async fn collect_unread(client: &Client) -> Vec<crate::protocol::RoomUnread> {
+    use crate::protocol::RoomUnread;
+    let mut result = Vec::new();
+    for room in client.joined_rooms() {
+        let count = room.unread_notification_counts().notification_count as u32;
+        if count == 0 {
+            continue;
+        }
+        let label = room
+            .canonical_alias()
+            .map(|a| a.to_string())
+            .unwrap_or_else(|| room.room_id().to_string());
+        let (last_body, last_sender) = if count == 1 {
+            fetch_last_message(client, &room).await
+        } else {
+            (None, None)
+        };
+        result.push(RoomUnread {
+            label,
+            count,
+            last_body,
+            last_sender,
+        });
+    }
+    result
+}
+
+/// Fetch the body + sender of the most recent room message. Returns
+/// `(None, None)` on any error or when the timeline contains no text
+/// events.
+async fn fetch_last_message(
+    client: &Client,
+    room: &matrix_sdk::Room,
+) -> (Option<String>, Option<String>) {
+    use matrix_sdk::ruma::api::Direction;
+    use matrix_sdk::ruma::api::client::message::get_message_events;
+    let mut req =
+        get_message_events::v3::Request::new(room.room_id().to_owned(), Direction::Backward);
+    req.limit = matrix_sdk::ruma::UInt::from(1u32);
+    let resp = match client.send(req).await {
+        Ok(r) => r,
+        Err(_) => return (None, None),
+    };
+    for raw in &resp.chunk {
+        if let Ok(ev) = raw.deserialize() {
+            let body = extract_body(&ev);
+            if !body.is_empty() {
+                return (
+                    Some(crate::wake::truncate_chars(&body, 100)),
+                    Some(ev.sender().to_string()),
+                );
+            }
+        }
+    }
+    (None, None)
+}
+
+/// Return per-room unread summaries. For rooms with exactly one
+/// unread notification, attempts to include the sender + truncated
+/// body; rooms with multiple unreads carry only the count.
+pub async fn unread_summary(client: &Client) -> DaemonResponse {
+    let rooms = collect_unread(client).await;
+    DaemonResponse::ok(&rooms)
+}