fix(desktop): restore channel unread badges

Treat interested non-DM thread replies as channel unread events again while keeping normal channel messages dot-only. Split sidebar badge counts from desktop app badge state so mentions/DMs/thread replies remain numeric, ordinary channel traffic only bolds the row, and any channel unread still lights the desktop app badge dot.

Co-authored-by: Pinky <44b8e82baa6e0e254e0208d68f335c283c94e7b78dd1fa10d5a49d3f13dd0435@sprout-oss.stage.blox.sqprod.co>
Signed-off-by: Wes <wesbillman@users.noreply.github.com>

Author: wesbillman

desktop/src/app/AppShell.tsx

@@ -390,11 +390,6 @@ export function AppShell() {
     channels,
   );
 
-  // Badge count is computed here (rather than inside useHomeFeedNotifications)
-  // so it can consume the NIP-RS read-state lifted from the single
-  // ReadStateManager mounted via useUnreadChannels above. Channel-backed
-  // feed items contribute to the badge iff strictly newer than that
-  // channel's read marker; non-channel items keep their seen-set fallback.
   const { homeBadgeCount, homeBadgeCountExcludingHighPriority } =
     useHomeFeedNotificationState(
       homeFeedQuery.data,
@@ -592,14 +587,18 @@ export function AppShell() {
   }, []);
 
   React.useEffect(() => {
-    const numericCount =
+    const count =
       unreadChannelNotificationCount + homeBadgeCountExcludingHighPriority;
-    if (numericCount > 0) {
-      void setDesktopAppBadge({ kind: "count", count: numericCount });
-    } else {
-      void setDesktopAppBadge({ kind: "none" });
-    }
-  }, [homeBadgeCountExcludingHighPriority, unreadChannelNotificationCount]);
+    void setDesktopAppBadge(
+      count
+        ? { kind: "count", count }
+        : { kind: unreadChannelIds.size ? "dot" : "none" },
+    );
+  }, [
+    homeBadgeCountExcludingHighPriority,
+    unreadChannelIds,
+    unreadChannelNotificationCount,
+  ]);
 
   // Dispatch `buzz://message` deep links into the router.
   useMessageDeepLinks();

desktop/src/features/channels/unreadChannelCounts.ts

@@ -3,8 +3,30 @@ export type ObservedUnreadEvent = {
   createdAt: number;
   rootId: string | null;
   highPriority: boolean;
+  countsTowardBadge: boolean;
+  countsTowardAppBadge: boolean;
 };
 
+export function makeObservedUnreadEvent(input: {
+  id: string;
+  createdAt: number;
+  rootId: string | null;
+  highPriority: boolean;
+  channelType: string | undefined;
+  isThreadedReply: boolean;
+}): ObservedUnreadEvent {
+  const isDm = input.channelType === "dm";
+  return {
+    id: input.id,
+    createdAt: input.createdAt,
+    rootId: input.rootId,
+    highPriority: input.highPriority,
+    countsTowardBadge: isDm || input.isThreadedReply || input.highPriority,
+    countsTowardAppBadge:
+      isDm || (!input.isThreadedReply && input.highPriority),
+  };
+}
+
 export function mapsEqual(
   a: ReadonlyMap<string, number>,
   b: ReadonlyMap<string, number>,
@@ -54,6 +76,34 @@ export function countUnreadObservedEvents(
   return count;
 }
 
+export function countUnreadBadgeObservedEvents(
+  eventsById: ReadonlyMap<string, ObservedUnreadEvent> | undefined,
+  getReadAt: (event: ObservedUnreadEvent) => number | null,
+): number {
+  if (!eventsById) return 0;
+  let count = 0;
+  for (const event of eventsById.values()) {
+    if (!event.countsTowardBadge) continue;
+    const readAt = getReadAt(event);
+    if (readAt === null || event.createdAt > readAt) count += 1;
+  }
+  return count;
+}
+
+export function countUnreadAppBadgeObservedEvents(
+  eventsById: ReadonlyMap<string, ObservedUnreadEvent> | undefined,
+  getReadAt: (event: ObservedUnreadEvent) => number | null,
+): number {
+  if (!eventsById) return 0;
+  let count = 0;
+  for (const event of eventsById.values()) {
+    if (!event.countsTowardAppBadge) continue;
+    const readAt = getReadAt(event);
+    if (readAt === null || event.createdAt > readAt) count += 1;
+  }
+  return count;
+}
+
 export function countUnreadHighPriorityObservedEvents(
   eventsById: ReadonlyMap<string, ObservedUnreadEvent> | undefined,
   getReadAt: (event: ObservedUnreadEvent) => number | null,

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

@@ -3,6 +3,8 @@ import test from "node:test";
 
 import { computeChannelUnreadMarker } from "../messages/lib/unreadMarker.ts";
 import {
+  countUnreadAppBadgeObservedEvents,
+  countUnreadBadgeObservedEvents,
   countUnreadHighPriorityObservedEvents,
   countUnreadObservedEvents,
   observedUnreadEventReadAt,
@@ -136,8 +138,22 @@ test("observedUnreadEventReadAt_nullChannelMarkerThreadMarkerCanClear", () => {
 
 // --- Fix 2b: sidebar badge evaluates all observed events, not a single aggregate frontier ---
 
-function observed(id, createdAt, rootId = null, highPriority = false) {
-  return { id, createdAt, rootId, highPriority };
+function observed(
+  id,
+  createdAt,
+  rootId = null,
+  highPriority = false,
+  countsTowardBadge = true,
+  countsTowardAppBadge = countsTowardBadge,
+) {
+  return {
+    id,
+    createdAt,
+    rootId,
+    highPriority,
+    countsTowardBadge,
+    countsTowardAppBadge,
+  };
 }
 
 function readAtFor(channelMarker, threadMarkers) {
@@ -219,6 +235,51 @@ test("countUnreadObservedEvents_topLevelUsesChannelMarker", () => {
   assert.equal(countUnreadObservedEvents(events, readAtFor(300, new Map())), 1);
 });
 
+test("countUnreadBadgeObservedEvents_skipsBoldOnlyGeneralChannelItems", () => {
+  const events = new Map([
+    ["plain", observed("plain", 500, null, false, false)],
+    ["thread", observed("thread", 600, "root-1")],
+  ]);
+
+  assert.equal(countUnreadObservedEvents(events, readAtFor(300, new Map())), 2);
+  assert.equal(
+    countUnreadBadgeObservedEvents(events, readAtFor(300, new Map())),
+    1,
+  );
+  assert.equal(
+    countUnreadAppBadgeObservedEvents(events, readAtFor(300, new Map())),
+    1,
+  );
+});
+
+test("countUnreadObservedEvents_countsThreadRepliesForChannelUnread", () => {
+  const events = new Map([
+    ["reply", observed("reply", 500, "root-1", false, true, false)],
+  ]);
+
+  assert.equal(countUnreadObservedEvents(events, readAtFor(300, new Map())), 1);
+  assert.equal(
+    countUnreadBadgeObservedEvents(events, readAtFor(300, new Map())),
+    1,
+  );
+  assert.equal(
+    countUnreadAppBadgeObservedEvents(events, readAtFor(300, new Map())),
+    0,
+  );
+});
+
+test("highPriorityObservedEvents_countsMentionBadgeForGeneralMessage", () => {
+  const events = new Map([
+    ["mention", observed("mention", 500, null, true, true)],
+  ]);
+  const getReadAt = readAtFor(300, new Map());
+
+  assert.equal(countUnreadObservedEvents(events, getReadAt), 1);
+  assert.equal(countUnreadBadgeObservedEvents(events, getReadAt), 1);
+  assert.equal(countUnreadAppBadgeObservedEvents(events, getReadAt), 1);
+  assert.equal(countUnreadHighPriorityObservedEvents(events, getReadAt), 1);
+});
+
 test("recordObservedUnreadEvent_reportsOutOfOrderInsertForInvalidation", () => {
   const channelId = "chan";
   const observedByChannel = new Map();

desktop/src/features/channels/unreadRootIdStore.ts

@@ -0,0 +1,30 @@
+// Per-pubkey JSON array of thread root ids, capped to newest entries and
+// tolerant of malformed or unavailable localStorage.
+export function makeRootIdStore(prefix: string, maxEntries = 1000) {
+  const storageKey = (pubkey: string) => `${prefix}:${pubkey}`;
+  return {
+    read(pubkey: string): Set<string> {
+      try {
+        const raw = window.localStorage.getItem(storageKey(pubkey));
+        if (!raw) return new Set();
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed)) return new Set();
+        return new Set(
+          parsed.filter((id): id is string => typeof id === "string"),
+        );
+      } catch {
+        return new Set();
+      }
+    },
+    write(pubkey: string, rootIds: Set<string>): void {
+      try {
+        const arr = [...rootIds];
+        const capped =
+          arr.length > maxEntries ? arr.slice(arr.length - maxEntries) : arr;
+        window.localStorage.setItem(storageKey(pubkey), JSON.stringify(capped));
+      } catch {
+        // Ignore storage errors (private browsing, quota exceeded).
+      }
+    },
+  };
+}

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

@@ -28,12 +28,11 @@ export type UseLiveChannelUpdatesOptions = {
   onDmMessage?: (event: RelayEvent, channel: Channel) => void;
   onLiveMention?: () => void;
   /**
-   * Fired for live main-channel "new content" events in a member channel
-   * authored by someone other than the current user. Non-DM thread replies
-   * are routed through onThreadReplyNotification instead; DM thread replies
-   * also fire this callback so the DM unread dot/count stays channel-level.
-   * Used to drive the in-session "latest message at" map that powers sidebar
-   * unread badges. See `UNREAD_TRIGGER_KINDS` for the exact kind set.
+   * Fired for live "new content" events in a member channel authored by
+   * someone other than the current user. Thread replies also fire
+   * onThreadReplyNotification so Home inbox activity stays in sync. Used to
+   * drive the observed unread-event map that powers sidebar unread state.
+   * See `UNREAD_TRIGGER_KINDS` for the exact kind set.
    */
   onChannelMessage?: (channelId: string, event: RelayEvent) => void;
   /**
@@ -73,13 +72,6 @@ const UNREAD_TRIGGER_KINDS = new Set<number>(CHANNEL_MESSAGE_EVENT_KINDS);
 
 export const EMPTY_SET: ReadonlySet<string> = new Set();
 
-export function shouldRouteChannelUnreadEvent(
-  channel: Pick<Channel, "channelType"> | undefined,
-  isThreadedReply: boolean,
-): boolean {
-  return !isThreadedReply || channel?.channelType === "dm";
-}
-
 function isExternalMentionEvent(event: RelayEvent, currentPubkey: string) {
   return (
     currentPubkey.length > 0 && event.pubkey.toLowerCase() !== currentPubkey
@@ -237,18 +229,11 @@ export function useLiveChannelUpdates(
         if (isThreadedReply) {
           options.onThreadReplyCandidate?.(channelId, event);
         }
-      } else if (
-        shouldRouteChannelUnreadEvent(
-          dmChannelMap.get(channelId),
-          isThreadedReply,
-        )
-      ) {
+      } else {
         options.onChannelMessage?.(channelId, event);
         if (isThreadedReply) {
           options.onThreadReplyNotification?.(channelId, event);
         }
-      } else {
-        options.onThreadReplyNotification?.(channelId, event);
       }
 
       if (shouldNotify && isThreadedReply) {