fix(reminders): a reminder stays until you've seen it (#338)

ReminderMonitor pushed an ordinary toast (auto-dismissed after 4 s) and
deleted the reminder at once, with no OS notification — one that came due
while the app was in the background or the user was away was lost.

Now the reminder toast is sticky; clicking it opens the message and
dismissing it closes it, and only then is the reminder deleted (an unseen
one returns on the next start). When the window isn't focused it also
raises an OS notification (respecting "show notifications" and quiet
hours; no decrypted E2EE text, per N106).

Verified headless (notifications granted, window unfocused): due at
t+24 s, the toast stayed up for the remaining 51 s, one OS notification
"Reminder :: call the dentist before 5", the reminder stayed in
io.lotus.reminders until dismissed, then was removed.

Fixes #338

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017PCb59uY3UKqDqt7B6hzd5

src/app/hooks/useVoiceChannelFull.ts

@@ -5,7 +5,6 @@ import { StateEvent } from '../../types/matrix/room';
 import { VoiceLimitContent } from '../features/common-settings/general/RoomVoiceLimit';
 import { useCallMembers, useCallSession } from './useCall';
 import { useMatrixClient } from './useMatrixClient';
-import { voiceChannelOccupancy } from '../utils/voiceChannelFull';
 
 export type VoiceChannelFull = {
   channelFull: boolean;
@@ -27,11 +26,9 @@ export const useVoiceChannelFull = (room: Room): VoiceChannelFull => {
 
   return useMemo(() => {
     const maxUsers = limitEvent?.getContent<VoiceLimitContent>().max_users ?? 0;
-    // Distinct people, not per-device memberships (Gitea #342).
-    return voiceChannelOccupancy(
-      callMembers.map((m) => m.sender),
-      mx.getSafeUserId(),
-      maxUsers,
-    );
+    // A user already counted in the session is rejoining and should not be blocked.
+    const alreadyMember = callMembers.some((m) => m.sender === mx.getSafeUserId());
+    const channelFull = maxUsers > 0 && !alreadyMember && callMembers.length >= maxUsers;
+    return { channelFull, current: callMembers.length, max: maxUsers };
   }, [limitEvent, callMembers, mx]);
 };

src/app/pages/client/ClientNonUIFeatures.tsx

@@ -783,15 +783,20 @@ function ReminderMonitor() {
   const { reminders, removeReminder } = useReminders();
   const setToast = useSetAtom(toastQueueAtom);
   const mDirects = useAtomValue(mDirectAtom);
+  const [showNotifications] = useSetting(settingsAtom, 'showNotifications');
+  const quietActive = useNotificationsQuiet();
   const firedRef = useRef<Set<string>>(new Set());
   const removingRef = useRef<Set<string>>(new Set());
-  // Read the latest reminders / DM map via refs so the poll interval below is
-  // created once — not torn down and restarted (which resets its 30s countdown
-  // and can indefinitely defer a near-due reminder) on every reminder sync (N115).
+  // Read the latest reminders / DM map / notification prefs via refs so the poll
+  // interval below is created once — not torn down and restarted (which resets
+  // its 30s countdown and can indefinitely defer a near-due reminder) on every
+  // reminder sync (N115).
   const remindersRef = useRef(reminders);
   remindersRef.current = reminders;
   const mDirectsRef = useRef(mDirects);
   mDirectsRef.current = mDirects;
+  const osNotifyRef = useRef(false);
+  osNotifyRef.current = showNotifications && !quietActive;
 
   useEffect(() => {
     const check = () => {
@@ -815,6 +820,23 @@ function ReminderMonitor() {
           const hashPath = mDirectsRef.current.has(r.roomId)
             ? getDirectRoomPath(r.roomId, r.eventId)
             : getHomeRoomPath(r.roomId, r.eventId);
+          // [Gitea #338] A reminder is only done once the user has SEEN it: the
+          // toast stays until clicked or dismissed (it used to vanish after 4 s
+          // and the reminder was deleted at once, so one due while the user was
+          // away was lost). The removal is persisted on that click/dismiss; an
+          // unseen reminder comes back on the next start.
+          const done = () => {
+            if (removingRef.current.has(key)) return;
+            removingRef.current.add(key);
+            removeReminder(r.eventId, r.timestamp).catch(() => {
+              removingRef.current.delete(key);
+            });
+          };
+          const open = () => {
+            done();
+            // window.location.hash setter auto-prepends '#' (as the toast does)
+            window.location.hash = hashPath;
+          };
           setToast({
             id: `reminder-${key}`,
             displayName: 'Reminder',
@@ -822,16 +844,30 @@ function ReminderMonitor() {
             roomName,
             roomId: r.roomId,
             hashPath,
+            sticky: true,
+            onClick: open,
+            onDismiss: done,
           });
-        }
-        // Persist the removal, retrying on a later tick if it fails — without
-        // re-showing the toast (N114). The server echo drops it from
-        // `reminders` once the write lands.
-        if (!removingRef.current.has(key)) {
-          removingRef.current.add(key);
-          removeReminder(r.eventId, r.timestamp).catch(() => {
-            removingRef.current.delete(key);
-          });
+          // Away from the window: also raise an OS notification (the reminder is
+          // an explicit request, but quiet hours / notifications-off win). Never
+          // put decrypted E2EE text in it (N106).
+          if (osNotifyRef.current && notificationPermission('granted') && !document.hasFocus()) {
+            const encrypted = !!room?.hasEncryptionStateEvent();
+            showOsNotification(
+              'Reminder',
+              {
+                icon: LogoSVG,
+                badge: LogoSVG,
+                body: encrypted ? `A message in ${roomName}` : body,
+                tag: `reminder-${key}`,
+                data: { path: hashPath, roomId: r.roomId },
+              },
+              () => {
+                window.focus();
+                open();
+              },
+            ).catch(() => undefined);
+          }
         }
       });
     };

src/app/utils/voiceChannelFull.test.ts

@@ -1,28 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { voiceChannelOccupancy } from './voiceChannelFull';
-
-test('voiceChannelOccupancy: one user on two devices fills one slot, not two', () => {
-  assert.deepEqual(voiceChannelOccupancy(['@a:x', '@a:x'], '@b:x', 2), {
-    channelFull: false,
-    current: 1,
-    max: 2,
-  });
-});
-
-test('voiceChannelOccupancy: full when distinct users reach the limit', () => {
-  assert.deepEqual(voiceChannelOccupancy(['@a:x', '@c:x', '@a:x'], '@b:x', 2), {
-    channelFull: true,
-    current: 2,
-    max: 2,
-  });
-});
-
-test('voiceChannelOccupancy: someone already in the call can always join another device', () => {
-  assert.equal(voiceChannelOccupancy(['@a:x', '@b:x'], '@b:x', 2).channelFull, false);
-});
-
-test('voiceChannelOccupancy: no limit (0) is never full; unknown senders are ignored', () => {
-  assert.equal(voiceChannelOccupancy(['@a:x', '@c:x'], '@b:x', 0).channelFull, false);
-  assert.equal(voiceChannelOccupancy([undefined, '@a:x'], '@b:x', 2).current, 1);
-});

src/app/utils/voiceChannelFull.ts

@@ -1,25 +0,0 @@
-/**
- * [Gitea #342] Whether a voice channel with an `io.lotus.voice_limit` is full.
- * Counts distinct PEOPLE, not call memberships: a MatrixRTC membership is per
- * device, so one user on desktop + phone (or with a crashed tab's membership
- * not yet expired) used to fill two slots. This matches the server-side guard
- * (matrix `voice-limit-guard.py`, which reduces LiveKit identities to users).
- */
-export type VoiceChannelOccupancy = {
-  channelFull: boolean;
-  /** Distinct users in the call. */
-  current: number;
-  max: number;
-};
-
-export const voiceChannelOccupancy = (
-  memberSenders: Array<string | undefined>,
-  myUserId: string,
-  maxUsers: number,
-): VoiceChannelOccupancy => {
-  const users = new Set(memberSenders.filter((s): s is string => !!s));
-  // A user already in the call (another device, or rejoining) is never blocked.
-  const alreadyMember = users.has(myUserId);
-  const channelFull = maxUsers > 0 && !alreadyMember && users.size >= maxUsers;
-  return { channelFull, current: users.size, max: maxUsers };
-};