feat(threads): Slack-style per-thread notifications (P4-1)

Default = Participating: thread replies notify only when you've posted in the
thread or are @mentioned; per-thread override to All / Mentions-only / Mute via
a bell menu in the thread panel header. Modes sync across devices in
io.lotus.thread_notifications account data (pruned on write: left rooms, >180d,
cap 200/room). Muted threads: no notifications/sounds, chip badge suppressed
(+BellMute glyph), and their counts are subtracted from the room's sidebar
badge (client-side; clamped ≥0).

Also fixes the thread notification path itself: thread replies are now owned by
exactly ONE handler (room-level ThreadEvent.NewReply via a new useRoomsListener
hook, with per-thread dedupe, panel-aware focus suppression, and per-thread OS
tag coalescing) — the existing RoomEvent.Timeline handlers in the notifier and
the unread binder are explicitly thread-guarded, eliminating the previously
un-gated/double path. Room badges now also refresh live on
RoomEvent.UnreadNotifications (surgical per-room PUT; fixes thread-badge lag).

Pure decision core shouldNotifyThreadReply (13-case matrix) + prune + unread
subtraction: +32 tests (648 total). E2EE caveat documented: mentions-only may
under-notify pre-decryption (same class as the existing path).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

src/app/hooks/useRoomsListener.ts

@@ -0,0 +1,64 @@
+import { useEffect, useRef } from 'react';
+import {
+  ClientEvent,
+  MatrixClient,
+  Room,
+  RoomEmittedEvents,
+  RoomEventHandlerMap,
+} from 'matrix-js-sdk';
+
+/**
+ * Attach `handler` for `event` on every joined/known room, including rooms
+ * created after mount (via `ClientEvent.Room`). All listeners are detached on
+ * unmount or when `mx`/`event` change.
+ *
+ * The handler is stored in a ref (mirroring `useTauriEvent`) so callers don't
+ * need to memoize it — changing the handler identity never re-attaches the
+ * per-room listeners.
+ *
+ * The emitting {@link Room} is appended as a FINAL extra argument after the
+ * event's own args: several room-level SDK events (e.g.
+ * `RoomEvent.UnreadNotifications`) don't include the room in their payload,
+ * which callers need for per-room updates. Handlers that don't care can simply
+ * ignore it.
+ */
+export function useRoomsListener<E extends RoomEmittedEvents>(
+  mx: MatrixClient,
+  event: E,
+  handler: (...args: [...Parameters<RoomEventHandlerMap[E]>, Room]) => void,
+): void {
+  const handlerRef = useRef(handler);
+  handlerRef.current = handler;
+
+  useEffect(() => {
+    // Track attached rooms (and their per-room trampolines) so re-emitted
+    // `ClientEvent.Room` (e.g. on membership changes) never double-subscribes,
+    // and cleanup can detach exactly what was attached.
+    const attached = new Map<string, (...args: unknown[]) => void>();
+
+    const attach = (room: Room) => {
+      if (attached.has(room.roomId)) return;
+      // Per-room trampoline: forwards to the current ref value with the
+      // emitting room appended.
+      const roomHandler = (...args: unknown[]) =>
+        (handlerRef.current as (...a: unknown[]) => void)(...args, room);
+      attached.set(room.roomId, roomHandler);
+      // `event`/`roomHandler` are correlated through E but TS can't prove it
+      // for the open generic, so we assert at the boundary.
+      room.on(event, roomHandler as any);
+    };
+
+    mx.getRooms().forEach(attach);
+
+    const handleRoom = (room: Room) => attach(room);
+    mx.on(ClientEvent.Room, handleRoom);
+
+    return () => {
+      mx.removeListener(ClientEvent.Room, handleRoom);
+      attached.forEach((roomHandler, roomId) => {
+        mx.getRoom(roomId)?.removeListener(event, roomHandler as any);
+      });
+      attached.clear();
+    };
+  }, [mx, event]);
+}

src/app/hooks/useThreadNotifications.ts

@@ -0,0 +1,97 @@
+import { useCallback } from 'react';
+import { useAtomValue } from 'jotai';
+import { MatrixClient } from 'matrix-js-sdk';
+import { AccountDataEvent } from '../../types/matrix/accountData';
+import { threadNotificationsAtom } from '../state/threadNotifications';
+import {
+  getThreadNotificationMode,
+  pruneThreadNotifications,
+  ThreadNotificationEntry,
+  ThreadNotificationMode,
+  ThreadNotificationsContent,
+} from '../utils/threadNotifications';
+import { useMatrixClient } from './useMatrixClient';
+import { AsyncState, useAsyncCallback } from './useAsyncCallback';
+
+/** Read the current notification mode for a thread from the bound atom. */
+export function useThreadNotificationMode(
+  roomId: string,
+  threadRootId: string,
+): ThreadNotificationMode {
+  const content = useAtomValue(threadNotificationsAtom);
+  return getThreadNotificationMode(content, roomId, threadRootId);
+}
+
+const readContent = (mx: MatrixClient): ThreadNotificationsContent =>
+  ((mx as any).getAccountData(AccountDataEvent.LotusThreadNotifications)?.getContent() as
+    | ThreadNotificationsContent
+    | undefined) ?? {};
+
+const getJoinedRoomIds = (mx: MatrixClient): Set<string> => {
+  const joined = new Set<string>();
+  mx.getRooms().forEach((room) => {
+    if (room.getMyMembership() === 'join') {
+      joined.add(room.roomId);
+    }
+  });
+  return joined;
+};
+
+const writeThreadNotificationMode = async (
+  mx: MatrixClient,
+  roomId: string,
+  threadRootId: string,
+  mode: ThreadNotificationMode,
+): Promise<void> => {
+  const current = readContent(mx);
+  const now = Date.now();
+
+  // Work on a mutable clone; prune produces a fresh object so the mutations
+  // below never touch the atom's/account-data's current content.
+  const next: ThreadNotificationsContent = {
+    ...current,
+    rooms: Object.fromEntries(
+      Object.entries(current.rooms ?? {}).map(([rid, entries]) => [rid, { ...entries }]),
+    ),
+  };
+
+  const rooms = next.rooms as Record<string, Record<string, ThreadNotificationEntry>>;
+
+  if (mode === ThreadNotificationMode.Default) {
+    if (rooms[roomId]) {
+      delete rooms[roomId][threadRootId];
+      if (Object.keys(rooms[roomId]).length === 0) {
+        delete rooms[roomId];
+      }
+    }
+  } else {
+    if (!rooms[roomId]) {
+      rooms[roomId] = {};
+    }
+    rooms[roomId][threadRootId] = { mode, ts: now };
+  }
+
+  // ALWAYS prune before persisting to keep account data bounded.
+  const finalContent = pruneThreadNotifications(next, getJoinedRoomIds(mx), now);
+
+  await (mx as any).setAccountData(AccountDataEvent.LotusThreadNotifications, finalContent);
+};
+
+export function useSetThreadNotificationMode(
+  roomId: string,
+  threadRootId: string,
+): {
+  modeState: AsyncState<void, Error>;
+  setMode: (mode: ThreadNotificationMode) => Promise<void>;
+} {
+  const mx = useMatrixClient();
+
+  const [modeState, setMode] = useAsyncCallback<void, Error, [ThreadNotificationMode]>(
+    useCallback(
+      (mode: ThreadNotificationMode) => writeThreadNotificationMode(mx, roomId, threadRootId, mode),
+      [mx, roomId, threadRootId],
+    ),
+  );
+
+  return { modeState, setMode };
+}

src/app/hooks/useThreadSummary.ts

@@ -1,4 +1,5 @@
 import { useEffect, useState } from 'react';
+import { useAtomValue } from 'jotai';
 import {
   MatrixEvent,
   NotificationCountType,
@@ -8,6 +9,8 @@ import {
   ThreadEvent,
 } from 'matrix-js-sdk';
 import { getThreadSummary, ThreadSummaryData } from '../features/room/thread/threadSummary';
+import { threadNotificationsAtom } from '../state/threadNotifications';
+import { getThreadNotificationMode, ThreadNotificationMode } from '../utils/threadNotifications';
 
 /**
  * Reactive thread summary + unread count for a root event's "N replies" chip.
@@ -18,9 +21,14 @@ import { getThreadSummary, ThreadSummaryData } from '../features/room/thread/thr
 export const useThreadSummary = (
   rootEvent: MatrixEvent,
   room: Room,
-): { summary: ThreadSummaryData | undefined; unread: number } => {
+): { summary: ThreadSummaryData | undefined; unread: number; mode: ThreadNotificationMode } => {
   const threadId = rootEvent.getId();
 
+  const threadNotifications = useAtomValue(threadNotificationsAtom);
+  const mode = threadId
+    ? getThreadNotificationMode(threadNotifications, room.roomId, threadId)
+    : ThreadNotificationMode.Default;
+
   const [summary, setSummary] = useState<ThreadSummaryData | undefined>(() =>
     getThreadSummary(rootEvent),
   );
@@ -53,5 +61,7 @@ export const useThreadSummary = (
     };
   }, [rootEvent, room, threadId]);
 
-  return { summary, unread };
+  const muted = mode === ThreadNotificationMode.Mute;
+
+  return { summary, unread: muted ? 0 : unread, mode };
 };