Improve inbox thread updates

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";
@@ -77,16 +78,24 @@ 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_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 };
@@ -163,13 +172,53 @@ 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 dispose: (() => Promise<void>) | null = null;
+
+    void relayClient
+      .subscribeLive(
+        {
+          kinds: [...HOME_FEED_ACTION_KINDS],
+          "#p": [pubkey],
+          limit: 50,
+          since: Math.floor(Date.now() / 1_000),
+        },
+        () => {
+          refetchHomeFeedFromLiveSignal();
+        },
+      )
+      .then((nextDispose) => {
+        if (isCancelled) {
+          void nextDispose().catch(() => {});
+          return;
+        }
+        dispose = nextDispose;
+      })
+      .catch((error) => {
+        console.error("Failed to subscribe to live home feed actions", error);
+      });
+
+    return () => {
+      isCancelled = true;
+      if (dispose) {
+        void dispose().catch(() => {});
+      }
+    };
+  }, [identityQuery.data?.pubkey]);
   const handleChannelNotification = React.useEffectEvent(
     (_channelId: string, _event: RelayEvent) => {
       if (!notificationSettings.settings.desktopEnabled) return;
@@ -307,6 +356,7 @@ export function AppShell() {
     markChannelUnread,
     unreadChannelIds,
     highPriorityUnreadChannelIds,
+    unreadChannelNotificationCount,
     getEffectiveTimestamp: getChannelReadAt,
     readStateVersion,
     setContextParentResolver,
@@ -325,7 +375,7 @@ export function AppShell() {
     notifyForActiveChannel: notificationSettings.settings.notifyWhileViewing,
     onChannelMessage: handleChannelNotification,
     onDmMessage: handleDmNotification,
-    onLiveMention: refetchHomeFeedOnLiveMention,
+    onLiveMention: refetchHomeFeedFromLiveSignal,
     onThreadReplyDesktopNotification: handleThreadReplyDesktopNotification,
     followedRootIds,
   });
@@ -344,6 +394,22 @@ export function AppShell() {
     },
     [markChannelRead],
   );
+  const threadActivityFeedItems = React.useMemo<FeedItem[]>(
+    () =>
+      threadActivityItems.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,
+      })),
+    [threadActivityItems],
+  );
 
   // Badge count is computed here (rather than inside useHomeFeedNotifications)
   // so it can consume the NIP-RS read-state lifted from the single
@@ -362,6 +428,9 @@ export function AppShell() {
       highPriorityUnreadChannelIds,
       feedProfilesQuery.data?.profiles,
       mutedChannelIds,
+      feedItemState.unreadSet,
+      threadActivityFeedItems,
+      getThreadReadAt,
     );
 
   const isNotifiedForThread = React.useCallback(
@@ -542,19 +611,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();
@@ -715,6 +778,7 @@ export function AppShell() {
             setTopbarSearchHidden,
             setTopbarSearchLoading,
             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;
@@ -34,6 +37,7 @@ type AppShellContextValue = {
   setTopbarSearchHidden: (hidden: boolean) => void;
   setTopbarSearchLoading: (loading: boolean) => void;
   threadActivityItems: ThreadActivityItem[];
+  feedItemState: FeedItemState;
 };
 
 const AppShellContext = React.createContext<AppShellContextValue>({
@@ -54,6 +58,14 @@ const AppShellContext = React.createContext<AppShellContextValue>({
   setTopbarSearchHidden: () => {},
   setTopbarSearchLoading: () => {},
   threadActivityItems: [],
+  feedItemState: {
+    doneSet: EMPTY_SET,
+    markDone: () => {},
+    markUnread: () => {},
+    undoDone: () => {},
+    undoUnread: () => {},
+    unreadSet: EMPTY_SET,
+  },
 });
 
 export function AppShellProvider({

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

@@ -159,9 +159,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;
@@ -170,10 +170,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

desktop/src/features/channels/unreadReadMarker.test.mjs

@@ -2,11 +2,8 @@ import assert from "node:assert/strict";
 import test from "node:test";
 
 import { computeChannelUnreadMarker } from "../messages/lib/unreadMarker.ts";
-import {
-  buildChannelThreadRoots,
-  channelUnreadFrontier,
-  resolveChannelReadMarker,
-} from "./useUnreadChannels.ts";
+import { isThreadReply } from "../messages/lib/threading.ts";
+import { resolveChannelReadMarker } from "./useUnreadChannels.ts";
 
 function topLevel(id, createdAt) {
   return { id, createdAt, author: "a", time: "", body: "", depth: 0 };
@@ -78,104 +75,27 @@ test("resolveChannelReadMarker_noCallerNoObserved_returnsNull", () => {
   assert.equal(result.clearObserved, false);
 });
 
-// --- Fix 2: sidebar dot folds per-thread read markers into the channel frontier ---
+// --- Sidebar dot routing: only main-channel activity belongs to the channel dot ---
 
-function replyItem(channelId, rootId) {
-  return {
-    id: `${channelId}:${rootId}:${Math.random()}`,
-    channelId,
-    tags: [["e", rootId, "", "root"]],
-  };
-}
-
-// rootId for these fixtures is the "root"-marked e-tag.
-const getRootId = (tags) =>
-  tags.find((t) => t[0] === "e" && t[3] === "root")?.[1] ?? null;
-
-test("buildChannelThreadRoots_groupsRootsByChannel", () => {
-  const items = [
-    replyItem("chan-a", "root-1"),
-    replyItem("chan-a", "root-1"), // dedup within a channel
-    replyItem("chan-a", "root-2"),
-    replyItem("chan-b", "root-3"),
-  ];
-  const map = buildChannelThreadRoots(items, getRootId);
-
-  assert.deepEqual([...(map.get("chan-a") ?? [])].sort(), ["root-1", "root-2"]);
-  assert.deepEqual([...(map.get("chan-b") ?? [])], ["root-3"]);
-  assert.equal(map.has("chan-c"), false);
-});
-
-test("buildChannelThreadRoots_skipsItemsWithNoRoot", () => {
-  const items = [{ id: "x", channelId: "chan-a", tags: [["p", "someone"]] }];
-  const map = buildChannelThreadRoots(items, getRootId);
-
-  assert.equal(map.size, 0);
-});
-
-test("channelUnreadFrontier_unopenedThreadReply_dotPersists", () => {
-  // Channel's only unread is a thread reply at t=500. The channel marker sits
-  // at the newest TOP-LEVEL message (t=300, Option-1) and the thread has never
-  // been opened (own marker null). Folded frontier stays at 300 < 500 → unread.
-  const channelMarker = 300;
-  const threadRoots = new Set(["root-1"]);
-  const getThreadOwnMarker = () => null; // never opened
-
-  const frontier = channelUnreadFrontier(
-    channelMarker,
-    threadRoots,
-    getThreadOwnMarker,
-  );
-
-  const latest = 500; // the thread reply timestamp
-  assert.equal(frontier, 300);
-  assert.equal(latest > frontier, true); // dot present (Will-accepted)
-});
-
-test("channelUnreadFrontier_openedThreadReply_dotClears", () => {
-  // Same channel, but the user opened the thread: markThreadRead advanced
-  // thread:root-1's OWN marker to 500 (the reply). Folded frontier rises to
-  // 500 ≥ latest → dot clears, even though the channel marker is still 300.
-  const channelMarker = 300;
-  const threadRoots = new Set(["root-1"]);
-  const getThreadOwnMarker = (rootId) => (rootId === "root-1" ? 500 : null);
-
-  const frontier = channelUnreadFrontier(
-    channelMarker,
-    threadRoots,
-    getThreadOwnMarker,
-  );
-
-  const latest = 500;
-  assert.equal(frontier, 500);
-  assert.equal(latest > frontier, false); // dot cleared
-});
-
-test("channelUnreadFrontier_noThreadRoots_usesChannelMarker", () => {
-  // No thread roots observed (or evicted) → channel marker governs unchanged.
+test("isThreadReply detects normal threaded replies", () => {
   assert.equal(
-    channelUnreadFrontier(300, undefined, () => null),
-    300,
-  );
-  assert.equal(
-    channelUnreadFrontier(null, undefined, () => null),
-    null,
+    isThreadReply([
+      ["h", "chan-a"],
+      ["e", "root-1", "", "root"],
+      ["e", "parent-1", "", "reply"],
+    ]),
+    true,
   );
 });
 
-test("channelUnreadFrontier_nullChannelMarker_threadMarkerGoverns", () => {
-  // Channel never marked read but a thread was opened: the thread's own marker
-  // becomes the frontier rather than crashing on the null channel marker.
-  const frontier = channelUnreadFrontier(null, new Set(["root-1"]), () => 500);
-  assert.equal(frontier, 500);
-});
-
-test("channelUnreadFrontier_takesMaxAcrossMultipleThreads", () => {
-  // Two opened threads with different markers → the highest wins.
-  const frontier = channelUnreadFrontier(
-    100,
-    new Set(["root-1", "root-2"]),
-    (rootId) => (rootId === "root-1" ? 400 : 700),
+test("isThreadReply treats top-level and broadcast replies as channel activity", () => {
+  assert.equal(isThreadReply([["h", "chan-a"]]), false);
+  assert.equal(
+    isThreadReply([
+      ["h", "chan-a"],
+      ["broadcast", "1"],
+      ["e", "root-1", "", "reply"],
+    ]),
+    false,
   );
-  assert.equal(frontier, 700);
 });