feat: surface pending matrix invites in get_loose_ends

Write mcp-loose-ends/matrix.json on invite arrival (before wake) and
after join_room clears an invite. The harness scans mcp-loose-ends/
generically in get_loose_ends, so pending invites are visible there
without any harness-side changes.

- paths: add mcp_loose_ends_dir() (mirrors hive-bash-mcp pattern)
- handlers: add refresh_invite_loose_ends() — atomic tmp+rename write
- handlers: join_room calls refresh after successful join to clear entry
- timeline: install_invite_handler refreshes loose-ends before wake

hive-matrix-mcp/src/handlers.rs

@@ -288,6 +288,46 @@ pub async fn list_invites(client: &Client) -> DaemonResponse {
     DaemonResponse::ok(&invites)
 }
 
+/// Rewrite `mcp-loose-ends/matrix.json` with a summary of all pending
+/// room invites. The harness scans this directory generically in
+/// `get_loose_ends` — no matrix-specific code needed there.
+///
+/// Called after an invite arrives (from the sync handler) and after a
+/// room is joined (to remove the accepted invite from loose-ends).
+/// Atomic write (tmp + rename) so the harness never reads a partial file.
+pub async fn refresh_invite_loose_ends(client: &Client) {
+    let invites = client.invited_rooms();
+    let dir = crate::paths::mcp_loose_ends_dir();
+    if let Err(e) = tokio::fs::create_dir_all(&dir).await {
+        tracing::warn!(error = ?e, "matrix: create mcp-loose-ends dir failed");
+        return;
+    }
+    let items: Vec<String> = invites
+        .iter()
+        .map(|room| {
+            let label = room
+                .canonical_alias()
+                .map_or_else(|| room.room_id().to_string(), |a| a.to_string());
+            format!(
+                "[matrix] pending invite: {label} — use list_invites to see, join_room to accept"
+            )
+        })
+        .collect();
+    let dest = dir.join("matrix.json");
+    let tmp = dest.with_extension("json.tmp");
+    let json = serde_json::to_string(&items).unwrap_or_else(|_| "[]".to_owned());
+    match tokio::fs::write(&tmp, &json).await {
+        Ok(()) => {
+            if let Err(e) = tokio::fs::rename(&tmp, &dest).await {
+                tracing::warn!(error = ?e, "matrix: rename mcp-loose-ends/matrix.json failed");
+            }
+        }
+        Err(e) => {
+            tracing::warn!(error = ?e, "matrix: write mcp-loose-ends/matrix.json.tmp failed");
+        }
+    }
+}
+
 pub async fn join_room(client: &Client, room_ref: &str) -> DaemonResponse {
     let parsed: &RoomOrAliasId = match room_ref.try_into() {
         Ok(p) => p,
@@ -297,10 +337,15 @@ pub async fn join_room(client: &Client, room_ref: &str) -> DaemonResponse {
     };
     let server_names: Vec<OwnedServerName> = vec![];
     match client.join_room_by_id_or_alias(parsed, &server_names).await {
-        Ok(room) => DaemonResponse::ok(&serde_json::json!({
-            "joined": true,
-            "room_id": room.room_id().to_string(),
-        })),
+        Ok(room) => {
+            // Refresh loose-ends so the accepted invite is removed from
+            // `get_loose_ends` output immediately after the agent joins.
+            refresh_invite_loose_ends(client).await;
+            DaemonResponse::ok(&serde_json::json!({
+                "joined": true,
+                "room_id": room.room_id().to_string(),
+            }))
+        }
         Err(e) => DaemonResponse::error(format!("join room {room_ref}: {e}")),
     }
 }