Improve inbox thread updates

desktop/scripts/check-file-sizes.mjs

@@ -39,6 +39,8 @@ const overrides = new Map([
   ["src-tauri/src/nostr_convert.rs", 1126],
   ["src/shared/api/relayClientSession.ts", 1022],
   ["src-tauri/src/migration.rs", 1295],
+  ["src/app/AppShell.tsx", 1080],
+  ["src/features/channels/useUnreadChannels.ts", 1660],
 ]);
 
 await runFileSizeCheck({

desktop/src/app/AppShell.tsx

@@ -28,6 +28,7 @@ import {
 } from "@/features/channels/hooks";
 import { useUnreadChannels } from "@/features/channels/useUnreadChannels";
 import { useMembershipNotifications } from "@/features/channels/useMembershipNotifications";
+import { useFeedItemState } from "@/features/home/useFeedItemState";
 import { getThreadReference } from "@/features/messages/lib/threading";
 import { hasMentionForEvent } from "@/features/notifications/lib/shouldNotify";
 import { useThreadFollows } from "@/features/messages/lib/useThreadFollows";
@@ -65,6 +66,7 @@ import {
   isSettingsSection,
 } from "@/features/settings/ui/SettingsPanels";
 import { HuddleBar, HuddleProvider } from "@/features/huddle";
+import { remindersQueryKey } from "@/features/reminders/hooks";
 import { RemindMeLaterProvider } from "@/features/reminders/ui/RemindMeLaterProvider";
 import { useReminderNotifications } from "@/features/reminders/useReminderNotifications";
 import { AppSidebar } from "@/features/sidebar/ui/AppSidebar";
@@ -77,16 +79,28 @@ import { useIdentityQuery } from "@/shared/api/hooks";
 import { useRelayAutoHeal } from "@/shared/api/useRelayAutoHeal";
 import { useDeferredStartup } from "@/shared/hooks/useDeferredStartup";
 import { joinChannel } from "@/shared/api/tauri";
-import type { Channel, RelayEvent, SearchHit } from "@/shared/api/types";
+import type {
+  Channel,
+  FeedItem,
+  RelayEvent,
+  SearchHit,
+} from "@/shared/api/types";
 import { ChannelNavigationProvider } from "@/shared/context/ChannelNavigationContext";
 import { MainInsetProvider } from "@/shared/layout/MainInsetContext";
 import { chromeCssVarDefaults } from "@/shared/layout/chromeLayout";
 import { cn } from "@/shared/lib/cn";
 import { hasPrimaryShortcutModifier } from "@/shared/lib/platform";
 import { useMessageDeepLinks } from "@/shared/useMessageDeepLinks";
+import {
+  KIND_APPROVAL_REQUEST,
+  KIND_EVENT_REMINDER,
+  KIND_REMINDER,
+} from "@/shared/constants/kinds";
 import { ConnectionBanner } from "@/shared/ui/ConnectionBanner";
 import { SidebarInset, SidebarProvider } from "@/shared/ui/sidebar";
 
+const HOME_FEED_ACTION_KINDS = [KIND_APPROVAL_REQUEST, KIND_REMINDER] as const;
+
 const LazySettingsScreen = React.lazy(async () => {
   const module = await import("@/features/settings/ui/SettingsScreen");
   return { default: module.SettingsScreen };
@@ -161,13 +175,85 @@ export function AppShell() {
   const setUserStatusMutation = useSetUserStatusMutation(deferredPubkey);
   const { feedProfilesQuery, homeFeedQuery, notificationSettings } =
     useHomeFeedNotifications(identityQuery.data?.pubkey);
+  const feedItemState = useFeedItemState(identityQuery.data?.pubkey);
   useReminderNotifications(
     identityQuery.data?.pubkey,
     notificationSettings.settings,
   );
-  const refetchHomeFeedOnLiveMention = React.useEffectEvent(() => {
+  const refetchHomeFeedFromLiveSignal = React.useEffectEvent(() => {
     void homeFeedQuery.refetch();
   });
+  React.useEffect(() => {
+    const pubkey = identityQuery.data?.pubkey?.trim().toLowerCase() ?? "";
+    if (!pubkey) {
+      return;
+    }
+
+    let isCancelled = false;
+    let disposers: Array<() => Promise<void>> = [];
+    const since = Math.floor(Date.now() / 1_000);
+    const handleLiveHomeFeedEvent = () => {
+      refetchHomeFeedFromLiveSignal();
+    };
+    const handleLiveReminderEvent = () => {
+      refetchHomeFeedFromLiveSignal();
+      void queryClient.invalidateQueries({
+        queryKey: remindersQueryKey(pubkey),
+      });
+    };
+
+    void Promise.allSettled([
+      relayClient.subscribeLive(
+        {
+          kinds: [...HOME_FEED_ACTION_KINDS],
+          "#p": [pubkey],
+          limit: 50,
+          since,
+        },
+        handleLiveHomeFeedEvent,
+      ),
+      relayClient.subscribeLive(
+        {
+          authors: [pubkey],
+          kinds: [KIND_EVENT_REMINDER],
+          limit: 50,
+          since,
+        },
+        handleLiveReminderEvent,
+      ),
+    ]).then((results) => {
+      const nextDisposers = results.flatMap((result) =>
+        result.status === "fulfilled" ? [result.value] : [],
+      );
+      for (const result of results) {
+        if (result.status === "rejected") {
+          console.error(
+            "Failed to subscribe to live home feed actions",
+            result.reason,
+          );
+        }
+      }
+
+      if (nextDisposers.length === 0) {
+        return;
+      }
+
+      if (isCancelled) {
+        for (const dispose of nextDisposers) {
+          void dispose().catch(() => {});
+        }
+        return;
+      }
+      disposers = nextDisposers;
+    });
+
+    return () => {
+      isCancelled = true;
+      for (const dispose of disposers) {
+        void dispose().catch(() => {});
+      }
+    };
+  }, [identityQuery.data?.pubkey, queryClient]);
   const handleChannelNotification = React.useEffectEvent(
     (_channelId: string, _event: RelayEvent) => {
       if (!notificationSettings.settings.desktopEnabled) return;
@@ -306,7 +392,9 @@ export function AppShell() {
     unreadChannelIds,
     unreadChannelCounts,
     highPriorityUnreadChannelIds,
+    unreadChannelNotificationCount,
     getEffectiveTimestamp: getChannelReadAt,
+    getOwnTimestamp: getOwnReadAt,
     readStateVersion,
     setContextParentResolver,
     participatedRootIds,
@@ -324,14 +412,28 @@ export function AppShell() {
     notifyForActiveChannel: notificationSettings.settings.notifyWhileViewing,
     onChannelMessage: handleChannelNotification,
     onDmMessage: handleDmNotification,
-    onLiveMention: refetchHomeFeedOnLiveMention,
+    onLiveMention: refetchHomeFeedFromLiveSignal,
     onThreadReplyDesktopNotification: handleThreadReplyDesktopNotification,
     followedRootIds,
   });
 
   const getThreadReadAt = React.useCallback(
-    (rootId: string) => getChannelReadAt(`thread:${rootId}`),
-    [getChannelReadAt],
+    (rootId: string, channelId?: string | null) => {
+      const threadReadAt = getOwnReadAt(`thread:${rootId}`);
+      if (!channelId) {
+        return threadReadAt;
+      }
+
+      const channelReadAt = getChannelReadAt(channelId);
+      if (threadReadAt === null) {
+        return channelReadAt;
+      }
+      if (channelReadAt === null) {
+        return threadReadAt;
+      }
+      return Math.max(threadReadAt, channelReadAt);
+    },
+    [getChannelReadAt, getOwnReadAt],
   );
 
   const markThreadRead = React.useCallback(
@@ -343,6 +445,28 @@ export function AppShell() {
     },
     [markChannelRead],
   );
+  const mutedRootIdsKey = [...mutedRootIds].sort().join("\0");
+  const threadActivityFeedItems = React.useMemo<FeedItem[]>(() => {
+    // mutedRootIds is a mutable Set; this key invalidates when contents change.
+    void mutedRootIdsKey;
+    return threadActivityItems
+      .filter((item) => {
+        const rootId = getThreadReference(item.tags).rootId;
+        return !rootId || !mutedRootIds.has(rootId);
+      })
+      .map((item) => ({
+        id: item.id,
+        kind: item.kind,
+        pubkey: item.pubkey,
+        content: item.content,
+        createdAt: item.createdAt,
+        channelId: item.channelId,
+        channelName: item.channelName,
+        channelType: undefined,
+        tags: item.tags,
+        category: "activity" as const,
+      }));
+  }, [mutedRootIds, mutedRootIdsKey, threadActivityItems]);
 
   // Badge count is computed here (rather than inside useHomeFeedNotifications)
   // so it can consume the NIP-RS read-state lifted from the single
@@ -361,6 +485,9 @@ export function AppShell() {
       highPriorityUnreadChannelIds,
       feedProfilesQuery.data?.profiles,
       mutedChannelIds,
+      feedItemState.unreadSet,
+      threadActivityFeedItems,
+      getThreadReadAt,
     );
 
   const isNotifiedForThread = React.useCallback(
@@ -537,19 +664,13 @@ export function AppShell() {
 
   React.useEffect(() => {
     const numericCount =
-      highPriorityUnreadChannelIds.size + homeBadgeCountExcludingHighPriority;
+      unreadChannelNotificationCount + homeBadgeCountExcludingHighPriority;
     if (numericCount > 0) {
       void setDesktopAppBadge({ kind: "count", count: numericCount });
-    } else if (unreadChannelIds.size > 0) {
-      void setDesktopAppBadge({ kind: "dot" });
     } else {
       void setDesktopAppBadge({ kind: "none" });
     }
-  }, [
-    homeBadgeCountExcludingHighPriority,
-    highPriorityUnreadChannelIds.size,
-    unreadChannelIds.size,
-  ]);
+  }, [homeBadgeCountExcludingHighPriority, unreadChannelNotificationCount]);
 
   // Dispatch `buzz://message` deep links into the router.
   useMessageDeepLinks();
@@ -707,7 +828,9 @@ export function AppShell() {
             unfollowThread: handleUnfollowThread,
             isFollowingThread,
             isNotifiedForThread,
+            isThreadMuted: (rootId) => mutedRootIds.has(rootId),
             threadActivityItems,
+            feedItemState,
           }}
         >
           <HuddleProvider>

desktop/src/app/AppShellContext.tsx

@@ -1,6 +1,9 @@
 import * as React from "react";
 import type { ContextParentResolver } from "@/features/channels/readState/readStateManager";
 import type { ThreadActivityItem } from "@/features/channels/useUnreadChannels";
+import type { FeedItemState } from "@/features/home/useFeedItemState";
+
+const EMPTY_SET = new Set<string>();
 
 type AppShellContextValue = {
   markAllChannelsRead: () => void;
@@ -18,7 +21,7 @@ type AppShellContextValue = {
   getChannelReadAt: (channelId: string) => number | null;
   // Thread read frontier as unix-seconds timestamp, or null when never read.
   // Uses `thread:<rootId>` context keys in the same ReadStateManager.
-  getThreadReadAt: (rootId: string) => number | null;
+  getThreadReadAt: (rootId: string, channelId?: string | null) => number | null;
   // Advance the thread read frontier to the given unix-seconds timestamp.
   markThreadRead: (rootId: string, timestamp: number) => void;
   // Bump-counter that invalidates whenever the read marker changes. Include
@@ -31,7 +34,9 @@ type AppShellContextValue = {
   unfollowThread: (rootId: string) => void;
   isFollowingThread: (rootId: string) => boolean;
   isNotifiedForThread: (rootId: string) => boolean;
+  isThreadMuted: (rootId: string) => boolean;
   threadActivityItems: ThreadActivityItem[];
+  feedItemState: FeedItemState;
 };
 
 const AppShellContext = React.createContext<AppShellContextValue>({
@@ -49,7 +54,16 @@ const AppShellContext = React.createContext<AppShellContextValue>({
   unfollowThread: () => {},
   isFollowingThread: () => false,
   isNotifiedForThread: () => false,
+  isThreadMuted: () => false,
   threadActivityItems: [],
+  feedItemState: {
+    doneSet: EMPTY_SET,
+    markDone: () => {},
+    markUnread: () => {},
+    undoDone: () => {},
+    undoUnread: () => {},
+    unreadSet: EMPTY_SET,
+  },
 });
 
 export function AppShellProvider({

desktop/src/app/routes/index.tsx

@@ -79,11 +79,8 @@ function HomeRouteComponent() {
     <HomeScreen
       availableChannelIds={availableChannelIds}
       currentPubkey={identityQuery.data?.pubkey}
-      onOpenChannel={(channelId) => {
-        void goChannel(channelId);
-      }}
-      onOpenContext={(channelId, messageId) => {
-        void goChannel(channelId, { messageId });
+      onOpenContext={(channelId, messageId, threadRootId) => {
+        void goChannel(channelId, { messageId, threadRootId });
       }}
     />
   );

desktop/src/features/channels/ui/ChannelScreen.tsx

@@ -95,6 +95,7 @@ export function ChannelScreen({
     unfollowThread,
     isFollowingThread,
     isNotifiedForThread,
+    isThreadMuted,
     readStateVersion,
   } = useAppShell();
   const {
@@ -189,9 +190,9 @@ export function ChannelScreen({
   // No `lastMessageAt` fallback: that timestamp is reply-inclusive (the backend
   // takes MAX(created_at) over kind-9 events without a parent filter), so using
   // it when the window has no top-level message would advance the channel
-  // marker past an unread reply and clear its thread/sidebar unread — the exact
-  // regression Fix A prevents. null suppresses the marker advance (markChannelRead
-  // early-returns on markAt === null) until a real top-level position is known.
+  // marker past an unread reply and clear its thread unread. null suppresses
+  // the marker advance (markChannelRead early-returns on markAt === null) until
+  // a real top-level position is known.
   const activeReadAt = latestActiveMessage
     ? new Date(latestActiveMessage.created_at * 1_000).toISOString()
     : null;
@@ -200,10 +201,9 @@ export function ChannelScreen({
       return;
     }
     // Passive channel-open: advance the marker to the newest top-level message
-    // only (NIP-RS Option 1). `topLevelOnly` stops the read-state layer folding
-    // in observed thread replies, so opening a channel clears the timeline but
-    // leaves thread badges intact until each thread is opened — and leaves the
-    // channel's sidebar dot lit (the reply is still unread for the channel).
+    // only (NIP-RS Option 1). Opening a channel clears the main timeline while
+    // leaving thread badges and Home inbox thread activity intact until each
+    // thread itself is read.
     markChannelRead(activeChannelId, activeReadAt, { topLevelOnly: true });
   }, [activeChannel?.isMember, activeChannelId, activeReadAt, markChannelRead]);
   // Install the NIP-RS parent resolver: every `thread:<root>` context evaluated
@@ -404,7 +404,7 @@ export function ChannelScreen({
     getThreadReadAt,
     markChannelUnread,
     markThreadRead,
-    isNotifiedForThread,
+    isThreadMuted,
     readStateVersion,
   });
   const editTargetMessage = React.useMemo(