From e7bee14a910f6c45a879c16b21d4d49767efac94 Mon Sep 17 00:00:00 2001
From: klopez4212 <klopez4212@gmail.com>
Date: Wed, 23 Sep 2026 10:25:42 +0100
Subject: [PATCH 1/8] feat(channels): let people remove DMs from the sidebar

Signed-off-by: klopez4212 <klopez4212@gmail.com>
---
 docs/assets/dm-hide/dm-row-default.png        | Bin 0 -> 1305 bytes
 docs/assets/dm-hide/dm-row-hover.png          | Bin 0 -> 1761 bytes
 src/bundled/channels/ChannelSidebarItem.tsx   |   3 +
 .../channels/ChannelSidebarRow.module.css     |  22 ++-
 .../channels/ChannelSidebarRow.test.tsx       |  27 +++
 src/bundled/channels/ChannelSidebarRow.tsx    |  15 ++
 src/bundled/channels/ChannelsPage.tsx         |  10 +-
 src/bundled/channels/sidebar-sections.test.ts |   5 +
 src/bundled/channels/sidebar-sections.ts      |   5 +-
 src/bundled/channels/useHiddenDms.test.tsx    | 165 ++++++++++++++++++
 src/bundled/channels/useHiddenDms.ts          | 127 ++++++++++++++
 .../relay/unread-invalidation.test.ts         |   8 +-
 src/features/relay/unread.test.ts             |   4 +
 src/features/relay/unread.ts                  |  15 ++
 tests/browser/sidebar-unread.spec.mjs         |  55 ++++++
 15 files changed, 456 insertions(+), 5 deletions(-)
 create mode 100644 docs/assets/dm-hide/dm-row-default.png
 create mode 100644 docs/assets/dm-hide/dm-row-hover.png
 create mode 100644 src/bundled/channels/useHiddenDms.test.tsx
 create mode 100644 src/bundled/channels/useHiddenDms.ts

diff --git a/docs/assets/dm-hide/dm-row-default.png b/docs/assets/dm-hide/dm-row-default.png
new file mode 100644
index 0000000000000000000000000000000000000000..26c912747957910c0139f7dad635100353e4aca8
GIT binary patch
literal 1305
zcmV+!1?KvRP)<h;3K|Lk000e1NJLTq008m;001Be0ssI2r~I<l000EeNkl<Zc%1B-
zStxCP6vy}d|0yJdxH6T@Qz1&oRE9!CcoHGADDhy(gD5Gb<bk5hBrk?iBH@JxL=j~w
znKERG4ENjF-Q9_6-+PX2pWSYK9!~qW7C-B({oTLcZ>>%1?d^>r2zl`zLlClqWKGBr
zk~JYiNY;c5Az2eLgk(*~5Rx?^LrB(y3?W$)GDH%xzPr1do1446y%oWAa&oe`xcKt&
zB3aiTk$xT|h5E8yUS7`2%ZrYV&dki5nwo-TXJ;olIoZU-#Lv&Kt*z}J=P4*CFf}y|
z4i3g=R#uks%Y0#7S65e|p`jKQ76AbPW@cu}5lX}*PKrbeTZ5=6>;C@!#Kc5vYwMz-
zA`cIb!otFahK7fS2MD^myE`c<sj{+iXlUrK^VHYZBSEdLt!HOv9UUE=ot-r`HQ(XF
zO-)Tr-PqWeot-^8I!aGZN963&C=r)9DH1Jg&GJKye|5UNymWSUURqkRv9Vz-*yil*
z?Pq3YTwGjO%l7uRmzUSx-X4|;o~dkYZT<cI2L=Y%VMa#A`1ttg>8aqZ-Q8U~J3HLz
z+}vE)pP!!*Dk8+QClQx8DH1Jg&7#g~jYk&WiqkaE*Vm7Yjh&d7;4BUf4p_NIM@M<)
zxxc?ZJUsOA@!>4q-riVUE-o$vcWrKNV#v9)w6r`uJz1kfT;ilioUk>HI<m%UZD3&V
z&S+$01iP{YT1SP!GY`(<*ek58tT+pMjg?+-7vP4R3qQ|#rQi}LMdF10MUIb;)6&v@
zD!>JXjEblu>&VE+_4W04#+8*7*tsDjzOb->eUN7!JPG)`xw+viY|U<@Km?beq2Xs?
zi0{&1iUbe)i<Fj@qCz`SfC~&66;VglmX?+{a&XlNKvANjqZ1Sq#17F^!nLojZ+Lh(
z&pfC&b#-+Q4h}fW{{B8TI2_{ycR4vZVffC)8YSWqCq?3f{Y54xCwYedf|{L>>gwwD
z_VypY$<EGhYHDH>XF;4#&{R4<KgV;%KM8)(-Q68!2TBkOUteDb2M1A%YHMo??!rC5
zXK!yW`=@b-=I7_p!(kNnObRY>QY22;8t4Do+FC|MdU|>i5)uLf1JURyDJel|h(;zB
z@297yu&^*xC-}n1LPbRdmJQ^WXDU}$*XHJC6dzdZ>+0&Jr>Fb+`mm@7?!piu!G(K_
z7A*EPJb`Ewpa77FYinx@n;tU8?)cx7BEiFk1#K2=1&)r6IM8E(!^;}BA%@o)cpt<s
zfIqUjx~hE2h1k$CW>i6oQIV065hxhP4D>pb?Ks!R#Khpsmz9;Vhivrw;^N};^z`ug
z*=*?TqixjE(t=YBa)Ar(+#<NEyu2JiLOM9H;n0uPyScf!bX?eKtE#Hl4%)Y-NZ7EU
z@3FBl^b>LSA0HoaZES1|A!4JzHS~~@lESD6o*(=o+ZT_Bh-hqVWK=}uzI9GcPH}Ou
zo15E57g|X9`T4`c!<+@Z?XIpaycGEBwAa_ypOqlOy6}Bb`h4u<XxxRhZEbB0bvE+}
zlFb7YjMbX|T4dCD9YcHvSWQDhLQu3Y#Fx>`!$f=}Dk>^IKAs_jfL3clhS2|86EcKk
zO~??EH6cSt)`ScpSramZWKGBrk~JYiegOag|Nm1U;m80000v1!K~w_(vzwfATpKu>
P00000NkvXXu0mjfo2q#w

literal 0
HcmV?d00001

diff --git a/docs/assets/dm-hide/dm-row-hover.png b/docs/assets/dm-hide/dm-row-hover.png
new file mode 100644
index 0000000000000000000000000000000000000000..71291e4621d2bbb7ae79b66ea4f3b4749126fd39
GIT binary patch
literal 1761
zcmV<71|Io|P)<h;3K|Lk000e1NJLTq008m;001Be0ssI2r~I<l000J-Nkl<Zc%1B<
zXJ`~#6vro<NHkINuvb*<iXAJWAcBe&R1g&r5ydW65JXWF>=hd-Dkvz5Xp#>}AP`6(
z`I10FLOP_7Knm&QrM$e~?v3NJ+015lXJ#jG{~v~#b9U~Wz4O24o^xjAhIDmxDVpf$
z=xA$e`_BQ7KbDYii=dz&K_0Q?(5utMSvH%EZKwktF4r4Vk^k#}A|c@);F7mI_Sj%Z
zNJv;%m>_yjxTm!swDipq76;@G4-fAtcSGx@rX~UpMMA<?s3C_r*BUx>sH@QV@<h*Y
znyn%s(XW8d#&fHOe?t@aEjcaGPvJscTW<;piT;I#h6Z)No7N<Vot>SEghYP^u37BZ
zX-)Xi+S;l}Nce|<m(JST+eO4-r?up?gf7sxIPIGO!eQHK%|k>bpum)*q@>2iMiW#O
z6%{EdDQ+V!i>Tbf;{6bCLaXTZ*7$A3C#0pNojZ4K*REYBPo9jAk4I8iSa|T@!6{Rw
ztXsG4-Me>vZ0Ev-3sa{~-Mo1-+f%1bIZtHzs_N?MwrtrlbLPwq8#YXvHqF^Wi>S=$
zA|uQ;BK)YYulGu>g6PBM+mn~?-@hL?aA5rS@kfpvnLBsx#fujoK782H(z0a9lGm?a
zZ{NQC=FOWwfBy8?&VvUJ=%D-e?-vvlJbn7~^XJdEZ{IdTMZX_9bSOJJJ1Q!Q?cTk6
zFI~DMMx#Yk=5&#1X8Vce=H@$h?i3XjxyX^+y?Ym}#<_UvAj%@%)<9}&YnLuv%D<X8
zaiWkg%`INMI5IMl(JUnN=9)EY($mw24<D}4)Vz7~XzKm@_u}yQ@#C?vvHAJ=x~u4p
z1q&81_P9NY<Nd8=%a+ZbKmWsr4;E3G(?zD4?LW%O${sy>bmGK`$&)7w38Z@S<_$5z
z=+UFK&$anbt4>TzguW`L!QjDzH*VY*7Z;~WnD`(%gIl8=#$0J>>B5BzRSA7pRaI3}
zQ=_{oH#e6<RmBr2CYijvJoYW3GN+3SGTVqCWZbxMr%#_|s>#X8;gIc%7cb79J?oLv
z7-RFnAiVXEAwyh*5fKr{oh5Lc3`3(GVsWmH^{RxZMsW;E-Bmzw^pvxT-wUl3ROWP%
zL1r72GU7VVoH_IA)vM^}Xo6cfJ$CF^k7r?wP4OONgjrcxF2anA4CLw|6i-f0W~$O?
zhmoK-0vJ^y_9GlHK_y<1v4|>wU8K9&I%3kKNn5vW{qf_+wr$&-0|af@d>Chp+D)4_
zso4qm^y$;Ufdf~qS|tuCD)9q?khN>qYP2(9!h}JC1~FZ#l9G}VCOBd#-Br`4Pv_7@
zC4?4HnbSoEnQh#I7{dBrzkco9xswV+adB~9PO%3ey}gL74N4y$KYsk@4~T&%eJGAt
zkRe4;sk*wFSwp)KM%3)tvoTjxV~FzEpD|;`fB^$^S8)&6e*5-KT$;PWWHM*Y9K~_Z
zte`TdiwrW`pdf?`J$v?yd>2Nsee&c9d8Eg)Fedow)vMlCLcV_ex_|%v6)RTk+qdu7
zv154UQKLrTym_oc^@Hq$e1cxMcI_Gwn8rN=q@LsfBp;!np;V(15)$6NeJe6weN{{*
zn1qUZObPbNl`D)uN?_sP;TBP0Gm{=YCT4ttx=44kkx;ClD&k_c|0pjnfBg6{Pemw`
zb2wte2zH)7e-6P&+cZwZQwKvnub#;K{{8#LjT>yK^(<e$oQem9BntJrckjM+>lWq0
zJ$v@R_#HcTELyba@ZrO=X3f%`WXFsd6B85j^5sih3)N7j8-r9>%PnC{Qp9CSxp(g#
z!_PV@eBt%$*Dqhb42KNuB7M!~LFW1M=h@fxU*3XY!zJ+0YIP3`8#W9s@sC!nT*)x&
z?OaB({WAj0Rr(CF(W6I?GRO5)Q9|M$5}c@#)YQ~3U%uciJT{9By$yGLRs3JZp4)UM
zuqw*2nVFdoQRxMi?FWVpB-1^-uB@yaIdWv*<tq5Uc3SgvFyOC+NRa8TUcDN(sz~?&
zA`q(2_U~kv^(3tWj`i!;lNc!y{y}`P+x;!0bl4L9L-&OfyhU(uu*fF6t9z6=eXI0I
zNT`59f&G#|t&rH9Mb>$1R-!*bJO>FBvz=e)_)BXztz8b3kno5=F`JOuIoxnvrbH~O
zAV1fY=r0iN*d>H^zxod8V{2=xT&zsO;-Fq078cf1uC=HX%$7?_O85h@YMDVxOKQZ-
zp4Uo~3js^`50e)H{vQAU|NnZT0i^%{00v1!K~w_(`*!c>z)ovJ00000NkvXXu0mjf
DSHEwR

literal 0
HcmV?d00001

diff --git a/src/bundled/channels/ChannelSidebarItem.tsx b/src/bundled/channels/ChannelSidebarItem.tsx
index a94735cf9..7f39d002a 100644
--- a/src/bundled/channels/ChannelSidebarItem.tsx
+++ b/src/bundled/channels/ChannelSidebarItem.tsx
@@ -29,6 +29,7 @@ export const ChannelSidebarItem = memo(function ChannelSidebarItem({
   onSelect,
   onNewSession,
   onOpenThread,
+  onHideDm,
 }: {
   channel: ChannelSummary;
   session: RelaySession;
@@ -43,6 +44,7 @@ export const ChannelSidebarItem = memo(function ChannelSidebarItem({
   onSelect: (id: string) => void;
   onNewSession: (id: string) => void;
   onOpenThread: (channelId: string, rootId: string) => void;
+  onHideDm?: (id: string) => void;
 }) {
   const Icon =
     channel.channelType === "dm"
@@ -97,6 +99,7 @@ export const ChannelSidebarItem = memo(function ChannelSidebarItem({
       onPrepare={(id) => session.channels.prepare?.(id)}
       onSelect={onSelect}
       onNewSession={onNewSession}
+      {...(onHideDm ? { onHideDm } : {})}
     />
   );
 });
diff --git a/src/bundled/channels/ChannelSidebarRow.module.css b/src/bundled/channels/ChannelSidebarRow.module.css
index df6b322ff..007660ffd 100644
--- a/src/bundled/channels/ChannelSidebarRow.module.css
+++ b/src/bundled/channels/ChannelSidebarRow.module.css
@@ -8,7 +8,7 @@
   background: transparent;
   transition:
     color var(--duration-state) var(--easing-state),
-    background-color var(--duration-state) var(--easing-state);
+    background-color 90ms cubic-bezier(0.23, 1, 0.32, 1);
 }
 .row:hover:not([data-selected]) {
   background: var(--affordance-subtle);
@@ -27,12 +27,32 @@
   opacity: 0;
   pointer-events: none;
   flex-shrink: 0;
+  transition: opacity 90ms cubic-bezier(0.23, 1, 0.32, 1);
+}
+.row .remove {
+  position: absolute;
+  inset-block: 0;
+  right: 0;
+  z-index: 1;
+  display: flex;
+  align-items: center;
+  justify-content: flex-end;
+  width: calc(var(--size-row) + var(--space-control-inset));
+  border-radius: inherit;
+  background-color: inherit;
 }
 .row:is(:hover, :has(:focus-visible)) .more,
 .row .more:has([data-popup-open]) {
   opacity: 1;
   pointer-events: auto;
 }
+.row .remove [data-icon-variant] {
+  color: var(--text-subtle);
+  transition-duration: 90ms;
+}
+.row .remove [data-icon-variant]:is(:hover, :focus-visible) {
+  color: var(--text-standard);
+}
 .iconSpace {
   width: 17px;
   flex: 0 0 17px;
diff --git a/src/bundled/channels/ChannelSidebarRow.test.tsx b/src/bundled/channels/ChannelSidebarRow.test.tsx
index 8db2d9f7c..e2df9a6b5 100644
--- a/src/bundled/channels/ChannelSidebarRow.test.tsx
+++ b/src/bundled/channels/ChannelSidebarRow.test.tsx
@@ -138,6 +138,33 @@ it("hides session actions when the Sessions plugin is unavailable", () => {
     screen.queryByRole("button", { name: "More options for Engineering" }),
   ).not.toBeInTheDocument();
 });
+it("offers a separate hide action only for DM rows", async () => {
+  const onHideDm = vi.fn();
+  const onSelect = vi.fn();
+  render(
+    <ChannelSidebarRow
+      channel={{ id: "dm", name: "Alice", channelType: "dm" }}
+      collapsed={false}
+      onToggle={() => {}}
+      icon={<svg />}
+      sessions={[]}
+      sessionsEnabled={false}
+      draft={false}
+      draftSelected={false}
+      onSelect={onSelect}
+      onPrepare={() => {}}
+      onNewSession={() => {}}
+      onHideDm={onHideDm}
+    />,
+  );
+  const remove = screen.getByRole("button", {
+    name: "Remove Alice from DMs",
+  });
+  expect(remove).not.toHaveAttribute("title");
+  await userEvent.setup().click(remove);
+  expect(onHideDm).toHaveBeenCalledWith("dm");
+  expect(onSelect).not.toHaveBeenCalled();
+});
 it("opens saved child sessions and retained drafts without a channel icon", async () => {
   const user = userEvent.setup();
   const callbacks = mount();
diff --git a/src/bundled/channels/ChannelSidebarRow.tsx b/src/bundled/channels/ChannelSidebarRow.tsx
index 2d372f705..c4bb4a469 100644
--- a/src/bundled/channels/ChannelSidebarRow.tsx
+++ b/src/bundled/channels/ChannelSidebarRow.tsx
@@ -4,6 +4,7 @@ import {
   CaretDownIcon,
   CaretRightIcon,
   DotsThreeVerticalIcon,
+  XIcon,
 } from "../../shared/design-system/icons/index";
 import { useId, useRef, type ReactElement, type ReactNode } from "react";
 import { Menu } from "@base-ui/react/menu";
@@ -27,6 +28,7 @@ export function ChannelSidebarRow({
   onSelect,
   onPrepare,
   onNewSession,
+  onHideDm,
 }: {
   channel: ChannelSummary;
   icon: ReactNode;
@@ -43,6 +45,7 @@ export function ChannelSidebarRow({
   onSelect: (id: string) => void;
   onPrepare: (id: string) => void;
   onNewSession: (id: string) => void;
+  onHideDm?: (id: string) => void;
 }) {
   const starting = useRef(false);
   const childrenId = useId();
@@ -162,6 +165,18 @@ export function ChannelSidebarRow({
             </Menu.Portal>
           </Menu.Root>
         )}
+        {channel.channelType === "dm" && onHideDm && (
+          <span className={`${styles.more} ${styles.remove}`}>
+            <IconButton
+              type="button"
+              size="compact"
+              shape="round"
+              aria-label={`Remove ${channel.name} from DMs`}
+              onClick={() => onHideDm(channel.id)}
+              icon={<XIcon size={15} aria-hidden="true" />}
+            />
+          </span>
+        )}
       </div>
       <div className={styles.sessions} id={childrenId} hidden={collapsed}>
         {draft && (
diff --git a/src/bundled/channels/ChannelsPage.tsx b/src/bundled/channels/ChannelsPage.tsx
index afcde219d..10ae3e6b9 100644
--- a/src/bundled/channels/ChannelsPage.tsx
+++ b/src/bundled/channels/ChannelsPage.tsx
@@ -63,6 +63,7 @@ import { readView, writeView } from "../../shared/view-state";
 import { useChannelLabels } from "./useChannelLabels";
 import { useSidebarPreferences } from "./useSidebarPreferences";
 import { isChannelSectionKey, sidebarSections } from "./sidebar-sections";
+import { useHiddenDms } from "./useHiddenDms";
 import { SidebarSectionIcon } from "./SidebarSectionIcon";
 import {
   CreateChannelDialog,
@@ -197,6 +198,7 @@ function ChannelWorkspace({
       .map((entry) => entry.channelId),
   ]);
   const preferences = useSidebarPreferences(queries.sidebarPreferences);
+  const hiddenDms = useHiddenDms(scope, queries);
   useEffect(() => {
     void queries.emoji.ensure();
   }, [queries]);
@@ -773,6 +775,11 @@ function ChannelWorkspace({
     [scope, viewer, current, showingThread],
   );
   const drawer = useChannelPanels(panels, drawerContext);
+  const sections = sidebarSections(
+    channels,
+    preferences.data,
+    hiddenDms.hiddenIds,
+  );
   return (
     <div
       className={`${styles.board} ${panel || showingThread || companion ? styles.withPanel : ""}`}
@@ -785,7 +792,7 @@ function ChannelWorkspace({
       <Panel as="aside" aria-label="Channel sidebar">
         <div className={styles.sidebar}>
           <SidebarUnread listRef={sidebar.list}>
-            {sidebarSections(channels, preferences.data).map((section) => {
+            {sections.map((section) => {
               const showsCreateChannel = isChannelSectionKey(section.key);
               return (
                 <details
@@ -864,6 +871,7 @@ function ChannelWorkspace({
                         onSelect={select}
                         onNewSession={startSession}
                         onOpenThread={openActivityThread}
+                        onHideDm={hiddenDms.hide}
                       />
                     );
                   })}
diff --git a/src/bundled/channels/sidebar-sections.test.ts b/src/bundled/channels/sidebar-sections.test.ts
index 92be77af4..79068193a 100644
--- a/src/bundled/channels/sidebar-sections.test.ts
+++ b/src/bundled/channels/sidebar-sections.test.ts
@@ -57,6 +57,11 @@ it("intersects groups/stars with active authorized streams, keeping forums and D
     ["dms", ["dm", "group-dm"]],
   ]);
   expect(sidebarSections(roster, preferences)[1]?.icon).toBe(":party:");
+  expect(
+    sidebarSections(roster, preferences, new Set(["dm", "group-dm"])).some(
+      (section) => section.key === "dms",
+    ),
+  ).toBe(false);
   expect(
     project(roster.filter((channel) => channel.id !== "star")),
   ).not.toContainEqual(["starred", ["star"]]);
diff --git a/src/bundled/channels/sidebar-sections.ts b/src/bundled/channels/sidebar-sections.ts
index b71f8fc3c..370c682e8 100644
--- a/src/bundled/channels/sidebar-sections.ts
+++ b/src/bundled/channels/sidebar-sections.ts
@@ -9,6 +9,7 @@ export function isChannelSectionKey(key: string) {
 export function sidebarSections(
   channels: readonly ChannelSummary[],
   preferences?: SidebarPreferences,
+  hiddenDms: ReadonlySet<string> = new Set(),
 ) {
   const active = channels.filter(
     (channel) =>
@@ -59,7 +60,9 @@ export function sidebarSections(
       key: "dms",
       title: "DMs",
       icon: undefined,
-      rows: active.filter((channel) => channel.channelType === "dm"),
+      rows: active.filter(
+        (channel) => channel.channelType === "dm" && !hiddenDms.has(channel.id),
+      ),
     },
   ].filter((section) => section.key === "channels" || section.rows.length);
 }
diff --git a/src/bundled/channels/useHiddenDms.test.tsx b/src/bundled/channels/useHiddenDms.test.tsx
new file mode 100644
index 000000000..641175437
--- /dev/null
+++ b/src/bundled/channels/useHiddenDms.test.tsx
@@ -0,0 +1,165 @@
+// @vitest-environment jsdom
+import { act, cleanup, renderHook } from "@testing-library/react";
+import { afterEach, expect, it, vi } from "vitest";
+import type { RelaySession } from "../../features/relay/session";
+import type { IncomingListener } from "../../features/relay/incoming";
+import { useHiddenDms } from "./useHiddenDms";
+
+afterEach(() => {
+  cleanup();
+  localStorage.clear();
+  vi.useRealTimers();
+});
+
+function fixture() {
+  let latest: { id: string; createdAt: number } | undefined = {
+    id: "before",
+    createdAt: 99,
+  };
+  const listeners = new Set<() => void>();
+  const incoming = new Set<IncomingListener>();
+  type ObserveSend = Parameters<
+    NonNullable<RelaySession["outbox"]>["observeSend"]
+  >[0];
+  const outgoing = new Set<ObserveSend>();
+  let onRead = () => {};
+  const read = vi.fn(async () => {
+    onRead();
+    return [];
+  });
+  const session = {
+    channels: {
+      list: () => ({
+        channels: [{ id: "dm", name: "DM", channelType: "dm" }],
+      }),
+    },
+    read,
+    outbox: {
+      observeSend(listener: ObserveSend) {
+        outgoing.add(listener);
+        return () => outgoing.delete(listener);
+      },
+    },
+    unread: {
+      snapshot: () => ({ latestMessage: latest }),
+      subscribe: (_target: unknown, listener: () => void) => {
+        listeners.add(listener);
+        return () => listeners.delete(listener);
+      },
+    },
+    subscribeIncoming(listener: IncomingListener) {
+      incoming.add(listener);
+      return () => incoming.delete(listener);
+    },
+  } as unknown as RelaySession;
+  return {
+    session,
+    read,
+    onNextRead(callback: () => void) {
+      onRead = callback;
+    },
+    evidence(id: string, createdAt: number) {
+      latest = { id, createdAt };
+      for (const listener of listeners) listener();
+    },
+    receive(channelId: string) {
+      for (const listener of incoming)
+        listener([
+          {
+            channelId,
+            messageId: "incoming",
+            createdAt: 100,
+            authorId: "sender",
+            previewContent: "hello",
+          },
+        ]);
+    },
+    deliver(channelId: string) {
+      for (const listener of outgoing)
+        listener(
+          { kind: 9, tags: [["h", channelId]] } as Parameters<ObserveSend>[0],
+          new AbortController().signal,
+        )?.([]);
+    },
+    pendingDelivery(channelId: string) {
+      const listener = [...outgoing][0];
+      return listener?.(
+        { kind: 9, tags: [["h", channelId]] } as Parameters<ObserveSend>[0],
+        new AbortController().signal,
+      );
+    },
+  };
+}
+
+it("hides per scope, survives remount, and restores on later verified activity", () => {
+  vi.useFakeTimers();
+  vi.setSystemTime(new Date(100_000));
+  const h = fixture();
+  const first = renderHook(() => useHiddenDms("community:alice", h.session));
+  act(() => first.result.current.hide("dm"));
+  expect(first.result.current.hiddenIds.has("dm")).toBe(true);
+  first.unmount();
+
+  const restored = renderHook(() => useHiddenDms("community:alice", h.session));
+  expect(restored.result.current.hiddenIds.has("dm")).toBe(true);
+  const other = renderHook(() => useHiddenDms("community:bob", h.session));
+  expect(other.result.current.hiddenIds.has("dm")).toBe(false);
+
+  act(() => h.evidence("older-backfill", 98));
+  expect(restored.result.current.hiddenIds.has("dm")).toBe(true);
+  act(() => h.evidence("new-message", 100));
+  expect(restored.result.current.hiddenIds.has("dm")).toBe(true);
+  act(() => h.evidence("later-message", 101));
+  expect(restored.result.current.hiddenIds.has("dm")).toBe(false);
+});
+
+it("restores a hidden DM on a new live message, including when its timestamp is old", () => {
+  vi.useFakeTimers();
+  vi.setSystemTime(new Date(100_000));
+  const h = fixture();
+  const view = renderHook(() => useHiddenDms("community:alice", h.session));
+  act(() => view.result.current.hide("dm"));
+  act(() => h.receive("different"));
+  expect(view.result.current.hiddenIds.has("dm")).toBe(true);
+  act(() => h.receive("dm"));
+  expect(view.result.current.hiddenIds.has("dm")).toBe(false);
+});
+
+it("checks a hidden DM directly on return for messages missed while closed", async () => {
+  vi.useFakeTimers();
+  vi.setSystemTime(new Date(100_000));
+  const h = fixture();
+  const first = renderHook(() => useHiddenDms("community:alice", h.session));
+  act(() => first.result.current.hide("dm"));
+  first.unmount();
+  h.onNextRead(() => h.evidence("offline-message", 101));
+  const restored = renderHook(() => useHiddenDms("community:alice", h.session));
+  await act(async () => {
+    await Promise.resolve();
+  });
+  expect(restored.result.current.hiddenIds.has("dm")).toBe(false);
+  expect(h.read).toHaveBeenCalledWith(
+    [{ kinds: [9, 40002], "#h": ["dm"], limit: 1 }],
+    expect.objectContaining({ priority: "background" }),
+  );
+});
+
+it("restores a hidden DM after an outgoing message is delivered", () => {
+  const h = fixture();
+  const view = renderHook(() => useHiddenDms("community:alice", h.session));
+  act(() => view.result.current.hide("dm"));
+  act(() => h.deliver("different"));
+  expect(view.result.current.hiddenIds.has("dm")).toBe(true);
+  act(() => h.deliver("dm"));
+  expect(view.result.current.hiddenIds.has("dm")).toBe(false);
+});
+
+it("does not restore a DM hidden again after an older send began", () => {
+  const h = fixture();
+  const view = renderHook(() => useHiddenDms("community:alice", h.session));
+  act(() => view.result.current.hide("dm"));
+  const finish = h.pendingDelivery("dm");
+  act(() => view.result.current.hide("dm"));
+  act(() => finish?.([]));
+  expect(view.result.current.hiddenIds.has("dm")).toBe(true);
+});
diff --git a/src/bundled/channels/useHiddenDms.ts b/src/bundled/channels/useHiddenDms.ts
new file mode 100644
index 000000000..997b11beb
--- /dev/null
+++ b/src/bundled/channels/useHiddenDms.ts
@@ -0,0 +1,127 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import type { RelaySession } from "../../features/relay/session";
+import { readView, writeView } from "../../shared/view-state";
+
+type HiddenDm = { id: string; hiddenAt: number; latestMessageId?: string };
+const key = "hidden-dms";
+
+function restore(scope: string): HiddenDm[] {
+  const saved = readView<unknown>(scope, key, []);
+  if (!Array.isArray(saved)) return [];
+  return saved.filter(
+    (entry): entry is HiddenDm =>
+      !!entry &&
+      typeof entry === "object" &&
+      typeof entry.id === "string" &&
+      typeof entry.hiddenAt === "number" &&
+      Number.isFinite(entry.hiddenAt) &&
+      (entry.latestMessageId === undefined ||
+        typeof entry.latestMessageId === "string"),
+  );
+}
+
+/** Local, viewer-scoped sidebar intent; verified message evidence restores a row. */
+export function useHiddenDms(scope: string, session: RelaySession) {
+  const [hidden, setHidden] = useState(() => restore(scope));
+  const current = useRef(hidden);
+  const update = useCallback(
+    (next: HiddenDm[]) => {
+      current.current = next;
+      setHidden(next);
+      writeView(scope, key, next);
+    },
+    [scope],
+  );
+  const show = useCallback(
+    (ids: readonly string[]) => {
+      const targets = new Set(ids);
+      const next = current.current.filter((entry) => !targets.has(entry.id));
+      if (next.length !== current.current.length) update(next);
+    },
+    [update],
+  );
+  const hide = useCallback(
+    (id: string) => {
+      const latest = session.unread.snapshot({
+        kind: "channel",
+        channelId: id,
+      }).latestMessage;
+      update([
+        ...current.current.filter((entry) => entry.id !== id),
+        {
+          id,
+          hiddenAt: Date.now(),
+          ...(latest ? { latestMessageId: latest.id } : {}),
+        },
+      ]);
+    },
+    [session, update],
+  );
+
+  useEffect(() => {
+    if (!hidden.length) return;
+    const check = () => {
+      const resurfaced = current.current.flatMap((entry) => {
+        const latest = session.unread.snapshot({
+          kind: "channel",
+          channelId: entry.id,
+        }).latestMessage;
+        return latest &&
+          latest.id !== entry.latestMessageId &&
+          latest.createdAt * 1000 > entry.hiddenAt
+          ? [entry.id]
+          : [];
+      });
+      if (resurfaced.length) show(resurfaced);
+    };
+    const stops = hidden.map((entry) =>
+      session.unread.subscribe({ kind: "channel", channelId: entry.id }, check),
+    );
+    const stopIncoming = session.subscribeIncoming((messages) =>
+      show(messages.map((message) => message.channelId)),
+    );
+    const stopOutgoing = session.outbox?.observeSend((event) => {
+      if (event.kind !== 9 && event.kind !== 40002) return;
+      const destinations = event.tags.filter(([name]) => name === "h");
+      const id = destinations.length === 1 ? destinations[0]?.[1] : undefined;
+      const hiddenAtSend = current.current.find((entry) => entry.id === id);
+      if (!id || !hiddenAtSend) return;
+      return () => {
+        if (current.current.includes(hiddenAtSend)) show([id]);
+      };
+    });
+    check();
+    return () => {
+      for (const stop of stops) stop();
+      stopIncoming();
+      stopOutgoing?.();
+    };
+  }, [hidden, session, show]);
+
+  useEffect(() => {
+    if (!hidden.length) return;
+    const controller = new AbortController();
+    // The shared unread repair is roster-wide and capped. Check each hidden DM's
+    // latest verified message so an offline arrival can restore it on return.
+    void (async () => {
+      for (const { id } of hidden) {
+        if (controller.signal.aborted) return;
+        const channel = session.channels
+          .list()
+          .channels.find((item) => item.id === id);
+        if (channel?.channelType !== "dm") continue;
+        try {
+          await session.read([{ kinds: [9, 40002], "#h": [id], limit: 1 }], {
+            signal: controller.signal,
+            priority: "background",
+          });
+        } catch {
+          // Live delivery and a later mount can still restore the row.
+        }
+      }
+    })();
+    return () => controller.abort();
+  }, [hidden, session]);
+
+  return { hiddenIds: new Set(hidden.map((entry) => entry.id)), hide };
+}
diff --git a/src/features/relay/unread-invalidation.test.ts b/src/features/relay/unread-invalidation.test.ts
index c8716856f..152294542 100644
--- a/src/features/relay/unread-invalidation.test.ts
+++ b/src/features/relay/unread-invalidation.test.ts
@@ -149,9 +149,13 @@ it("lazily refreshes dormant selectors and preserves identity when their value i
   const target = at(h.targets, 0);
   const before = h.unread.snapshot(target);
   at(h.stops, 0)();
-  h.owner.accept([message(h.viewer, "c0", "own message", 12)]);
+  const own = message(h.viewer, "c0", "own message", 12);
+  h.owner.accept([own]);
   expect(h.state).not.toHaveBeenCalled();
-  expect(h.unread.snapshot(target)).toBe(before);
+  const after = h.unread.snapshot(target);
+  expect(after).not.toBe(before);
+  expect(after.latestMessage).toEqual({ id: own.id, createdAt: 12 });
+  expect(h.unread.snapshot(target)).toBe(after);
   expect(h.state).toHaveBeenCalledTimes(1);
   h.reset();
   h.owner.accept([message(h.peer, "c0", "unread message", 13)]);
diff --git a/src/features/relay/unread.test.ts b/src/features/relay/unread.test.ts
index be2baee44..a51472f68 100644
--- a/src/features/relay/unread.test.ts
+++ b/src/features/relay/unread.test.ts
@@ -118,6 +118,10 @@ it("production live evidence feeds stable snapshots; selection/prefetch do not r
     observedCount: 1,
     attentionCount: 1,
     coverage: "observed",
+    latestMessage: {
+      id: message(h.viewer, "room", "own", 12).id,
+      createdAt: 12,
+    },
   });
   const snapshot = h.snapshot(),
     changed = vi.fn();
diff --git a/src/features/relay/unread.ts b/src/features/relay/unread.ts
index 9de0d3529..e28331a1b 100644
--- a/src/features/relay/unread.ts
+++ b/src/features/relay/unread.ts
@@ -18,6 +18,8 @@ import { threadReference } from "./thread-reference";
 
 export type UnreadSnapshot = Readonly<{
   target: ReadTarget;
+  /** Latest verified content evidence, including read and self-authored messages. */
+  latestMessage?: Readonly<{ id: string; createdAt: number }>;
   /** null means unobserved/denied, never a fabricated zero or an exact relay total. */
   observedCount: number | null;
   attentionCount: number | null;
@@ -346,7 +348,16 @@ export function createUnread({
         .channels.find((channel) => channel.id === target.channelId)
         ?.channelType === "dm";
     indexEvidence();
+    let latest: RelayEvent | undefined;
     for (const entry of byChannel.get(target.channelId) ?? []) {
+      const event = entry.event;
+      if (
+        target.kind === "channel" &&
+        (!latest ||
+          event.created_at > latest.created_at ||
+          (event.created_at === latest.created_at && event.id < latest.id))
+      )
+        latest = event;
       if (!inTarget(entry.event, target) || !isUnread(entry, state)) continue;
       count++;
       if (priority(entry, dm)) attention++;
@@ -361,6 +372,9 @@ export function createUnread({
         : "none";
     return Object.freeze({
       target,
+      ...(latest
+        ? { latestMessage: { id: latest.id, createdAt: latest.created_at } }
+        : {}),
       observedCount: evidence ? count : null,
       attentionCount: evidence ? attention : null,
       coverage: evidence ? "observed" : "unknown",
@@ -370,6 +384,7 @@ export function createUnread({
     });
   }
   const equal = (a: UnreadSnapshot, b: UnreadSnapshot) =>
+    a.latestMessage?.id === b.latestMessage?.id &&
     a.observedCount === b.observedCount &&
     a.attentionCount === b.attentionCount &&
     a.coverage === b.coverage &&
diff --git a/tests/browser/sidebar-unread.spec.mjs b/tests/browser/sidebar-unread.spec.mjs
index 7793e2391..d52f58310 100644
--- a/tests/browser/sidebar-unread.spec.mjs
+++ b/tests/browser/sidebar-unread.spec.mjs
@@ -48,6 +48,61 @@ const heads = (app) =>
     ({ filter }) => filter.kinds?.includes(9) && filter["#h"]?.length === 1,
   );
 
+test("DM hide control removes a row and a new message restores it", async ({
+  page,
+  app,
+}, info) => {
+  await open(page, app);
+  const dm = row(page, "dm-030");
+  await expect(dm).toBeVisible();
+  const badge = dm.locator("[data-channel-unread]");
+  await expect(badge).toBeVisible();
+  const badgePosition = () =>
+    dm.evaluate((button) => {
+      const badge = button.querySelector("[data-channel-unread]");
+      if (!badge) throw new Error("DM unread indicator is missing");
+      const row = button.getBoundingClientRect();
+      const marker = badge.getBoundingClientRect();
+      return { x: marker.x - row.x, y: marker.y - row.y };
+    });
+  const before = await badgePosition();
+  const container = dm.locator("..").locator("..");
+  await container.screenshot({ path: info.outputPath("dm-row-default.png") });
+  await dm.hover();
+  const hide = dm
+    .locator("..")
+    .locator("..")
+    .getByRole("button", {
+      name: /Remove .* from DMs/,
+    });
+  await expect(hide).toBeVisible();
+  await expect
+    .poll(() =>
+      hide.evaluate((button) => getComputedStyle(button.parentElement).opacity),
+    )
+    .toBe("1");
+  await container.screenshot({ path: info.outputPath("dm-row-hover.png") });
+  const after = await badgePosition();
+  expect(after.x).toBeCloseTo(before.x, 0);
+  expect(after.y).toBeCloseTo(before.y, 0);
+  const primary = await dm.evaluate((button) => getComputedStyle(button).color);
+  const secondary = await hide.evaluate(
+    (button) => getComputedStyle(button).color,
+  );
+  expect(secondary).not.toBe(primary);
+  await hide.hover();
+  await expect
+    .poll(() => hide.evaluate((button) => getComputedStyle(button).color))
+    .toBe(primary);
+  await hide.click();
+  await expect(dm).toHaveCount(0);
+  await page.reload();
+  await expect(dm).toHaveCount(0);
+
+  app.append("primary", "dm-030", "A new DM", false, false);
+  await expect(dm).toBeVisible();
+});
+
 test("channel establishment preserves an in-flight unread batch and its sidebar badges", async ({
   page,
   app,

From 3999840b76d00bc37e48549d5368df491174eeba Mon Sep 17 00:00:00 2001
From: klopez4212 <klopez4212@gmail.com>
Date: Wed, 23 Sep 2026 13:41:31 +0100
Subject: [PATCH 2/8] fix(channels): restore hidden DMs from message identity

Signed-off-by: klopez4212 <klopez4212@gmail.com>
---
 src/bundled/channels/useHiddenDms.test.tsx |  8 +++-----
 src/bundled/channels/useHiddenDms.ts       | 11 ++---------
 tests/browser/sidebar-unread.spec.mjs      | 18 +++++++++++++++++-
 3 files changed, 22 insertions(+), 15 deletions(-)

diff --git a/src/bundled/channels/useHiddenDms.test.tsx b/src/bundled/channels/useHiddenDms.test.tsx
index 641175437..4f2fbb3e2 100644
--- a/src/bundled/channels/useHiddenDms.test.tsx
+++ b/src/bundled/channels/useHiddenDms.test.tsx
@@ -14,7 +14,7 @@ afterEach(() => {
 function fixture() {
   let latest: { id: string; createdAt: number } | undefined = {
     id: "before",
-    createdAt: 99,
+    createdAt: 90,
   };
   const listeners = new Set<() => void>();
   const incoming = new Set<IncomingListener>();
@@ -105,11 +105,9 @@ it("hides per scope, survives remount, and restores on later verified activity",
   const other = renderHook(() => useHiddenDms("community:bob", h.session));
   expect(other.result.current.hiddenIds.has("dm")).toBe(false);
 
-  act(() => h.evidence("older-backfill", 98));
+  act(() => h.evidence("before", 90));
   expect(restored.result.current.hiddenIds.has("dm")).toBe(true);
   act(() => h.evidence("new-message", 100));
-  expect(restored.result.current.hiddenIds.has("dm")).toBe(true);
-  act(() => h.evidence("later-message", 101));
   expect(restored.result.current.hiddenIds.has("dm")).toBe(false);
 });
 
@@ -132,7 +130,7 @@ it("checks a hidden DM directly on return for messages missed while closed", asy
   const first = renderHook(() => useHiddenDms("community:alice", h.session));
   act(() => first.result.current.hide("dm"));
   first.unmount();
-  h.onNextRead(() => h.evidence("offline-message", 101));
+  h.onNextRead(() => h.evidence("offline-message", 98));
   const restored = renderHook(() => useHiddenDms("community:alice", h.session));
   await act(async () => {
     await Promise.resolve();
diff --git a/src/bundled/channels/useHiddenDms.ts b/src/bundled/channels/useHiddenDms.ts
index 997b11beb..5fe6c881b 100644
--- a/src/bundled/channels/useHiddenDms.ts
+++ b/src/bundled/channels/useHiddenDms.ts
@@ -2,7 +2,7 @@ import { useCallback, useEffect, useRef, useState } from "react";
 import type { RelaySession } from "../../features/relay/session";
 import { readView, writeView } from "../../shared/view-state";
 
-type HiddenDm = { id: string; hiddenAt: number; latestMessageId?: string };
+type HiddenDm = { id: string; latestMessageId?: string };
 const key = "hidden-dms";
 
 function restore(scope: string): HiddenDm[] {
@@ -13,8 +13,6 @@ function restore(scope: string): HiddenDm[] {
       !!entry &&
       typeof entry === "object" &&
       typeof entry.id === "string" &&
-      typeof entry.hiddenAt === "number" &&
-      Number.isFinite(entry.hiddenAt) &&
       (entry.latestMessageId === undefined ||
         typeof entry.latestMessageId === "string"),
   );
@@ -50,7 +48,6 @@ export function useHiddenDms(scope: string, session: RelaySession) {
         ...current.current.filter((entry) => entry.id !== id),
         {
           id,
-          hiddenAt: Date.now(),
           ...(latest ? { latestMessageId: latest.id } : {}),
         },
       ]);
@@ -66,11 +63,7 @@ export function useHiddenDms(scope: string, session: RelaySession) {
           kind: "channel",
           channelId: entry.id,
         }).latestMessage;
-        return latest &&
-          latest.id !== entry.latestMessageId &&
-          latest.createdAt * 1000 > entry.hiddenAt
-          ? [entry.id]
-          : [];
+        return latest && latest.id !== entry.latestMessageId ? [entry.id] : [];
       });
       if (resurfaced.length) show(resurfaced);
     };
diff --git a/tests/browser/sidebar-unread.spec.mjs b/tests/browser/sidebar-unread.spec.mjs
index d52f58310..8c1be4dc9 100644
--- a/tests/browser/sidebar-unread.spec.mjs
+++ b/tests/browser/sidebar-unread.spec.mjs
@@ -97,9 +97,17 @@ test("DM hide control removes a row and a new message restores it", async ({
   await hide.click();
   await expect(dm).toHaveCount(0);
   await page.reload();
+  await expect(row(page, "dm-031")).toBeVisible();
   await expect(dm).toHaveCount(0);
 
-  app.append("primary", "dm-030", "A new DM", false, false);
+  app.append("primary", "dm-030", "A new live DM", true, false);
+  await expect(dm).toBeVisible();
+  await dm.hover();
+  await hide.click();
+  await expect(dm).toHaveCount(0);
+  app.append("primary", "dm-030", "A DM missed while closed", false, false);
+  await page.reload();
+  await expect(row(page, "dm-031")).toBeVisible();
   await expect(dm).toBeVisible();
 });
 
@@ -285,9 +293,17 @@ test("edge pills follow scroll and reveal the nearest unread without selection o
   await expect.poll(() => inView(page, "dm-030")).toBe(true);
   await expect(row(page, "dm-030")).toBeFocused();
   if (info.project.name === "chromium") {
+    await page.keyboard.press("Tab");
+    const remove = row(page, "dm-030")
+      .locator("..")
+      .locator("..")
+      .getByRole("button", { name: /Remove .* from DMs/ });
+    await expect(remove).toBeFocused();
     await page.keyboard.press("Tab");
     await expect(row(page, "dm-031")).toBeFocused();
     await page.keyboard.press("Shift+Tab");
+    await expect(remove).toBeFocused();
+    await page.keyboard.press("Shift+Tab");
     await expect(row(page, "dm-030")).toBeFocused();
   }
   await page.keyboard.press("Enter");

From 2b65987f536376481e52f025f68db70d7f97f406 Mon Sep 17 00:00:00 2001
From: klopez4212 <klopez4212@gmail.com>
Date: Wed, 23 Sep 2026 14:01:49 +0100
Subject: [PATCH 3/8] fix(channels): verify hidden DM heads after roster
 discovery

Signed-off-by: klopez4212 <klopez4212@gmail.com>
---
 src/bundled/channels/ChannelsPage.tsx      |  2 +-
 src/bundled/channels/useHiddenDms.test.tsx | 98 ++++++++++++++++++++--
 src/bundled/channels/useHiddenDms.ts       | 90 +++++++++++++++-----
 3 files changed, 159 insertions(+), 31 deletions(-)

diff --git a/src/bundled/channels/ChannelsPage.tsx b/src/bundled/channels/ChannelsPage.tsx
index 10ae3e6b9..a65e4148c 100644
--- a/src/bundled/channels/ChannelsPage.tsx
+++ b/src/bundled/channels/ChannelsPage.tsx
@@ -198,7 +198,7 @@ function ChannelWorkspace({
       .map((entry) => entry.channelId),
   ]);
   const preferences = useSidebarPreferences(queries.sidebarPreferences);
-  const hiddenDms = useHiddenDms(scope, queries);
+  const hiddenDms = useHiddenDms(scope, queries, list);
   useEffect(() => {
     void queries.emoji.ensure();
   }, [queries]);
diff --git a/src/bundled/channels/useHiddenDms.test.tsx b/src/bundled/channels/useHiddenDms.test.tsx
index 4f2fbb3e2..88f21c79c 100644
--- a/src/bundled/channels/useHiddenDms.test.tsx
+++ b/src/bundled/channels/useHiddenDms.test.tsx
@@ -3,6 +3,7 @@ import { act, cleanup, renderHook } from "@testing-library/react";
 import { afterEach, expect, it, vi } from "vitest";
 import type { RelaySession } from "../../features/relay/session";
 import type { IncomingListener } from "../../features/relay/incoming";
+import type { ChannelList } from "../../features/relay/contracts";
 import { useHiddenDms } from "./useHiddenDms";
 
 afterEach(() => {
@@ -12,6 +13,12 @@ afterEach(() => {
 });
 
 function fixture() {
+  const list: ChannelList = {
+    status: "ready",
+    channels: [
+      { id: "dm", channelType: "dm" } as ChannelList["channels"][number],
+    ],
+  };
   let latest: { id: string; createdAt: number } | undefined = {
     id: "before",
     createdAt: 90,
@@ -54,6 +61,7 @@ function fixture() {
   } as unknown as RelaySession;
   return {
     session,
+    list,
     read,
     onNextRead(callback: () => void) {
       onRead = callback;
@@ -62,6 +70,10 @@ function fixture() {
       latest = { id, createdAt };
       for (const listener of listeners) listener();
     },
+    clearHead() {
+      latest = undefined;
+      for (const listener of listeners) listener();
+    },
     receive(channelId: string) {
       for (const listener of incoming)
         listener([
@@ -95,14 +107,20 @@ it("hides per scope, survives remount, and restores on later verified activity",
   vi.useFakeTimers();
   vi.setSystemTime(new Date(100_000));
   const h = fixture();
-  const first = renderHook(() => useHiddenDms("community:alice", h.session));
+  const first = renderHook(() =>
+    useHiddenDms("community:alice", h.session, h.list),
+  );
   act(() => first.result.current.hide("dm"));
   expect(first.result.current.hiddenIds.has("dm")).toBe(true);
   first.unmount();
 
-  const restored = renderHook(() => useHiddenDms("community:alice", h.session));
+  const restored = renderHook(() =>
+    useHiddenDms("community:alice", h.session, h.list),
+  );
   expect(restored.result.current.hiddenIds.has("dm")).toBe(true);
-  const other = renderHook(() => useHiddenDms("community:bob", h.session));
+  const other = renderHook(() =>
+    useHiddenDms("community:bob", h.session, h.list),
+  );
   expect(other.result.current.hiddenIds.has("dm")).toBe(false);
 
   act(() => h.evidence("before", 90));
@@ -115,7 +133,9 @@ it("restores a hidden DM on a new live message, including when its timestamp is
   vi.useFakeTimers();
   vi.setSystemTime(new Date(100_000));
   const h = fixture();
-  const view = renderHook(() => useHiddenDms("community:alice", h.session));
+  const view = renderHook(() =>
+    useHiddenDms("community:alice", h.session, h.list),
+  );
   act(() => view.result.current.hide("dm"));
   act(() => h.receive("different"));
   expect(view.result.current.hiddenIds.has("dm")).toBe(true);
@@ -127,11 +147,15 @@ it("checks a hidden DM directly on return for messages missed while closed", asy
   vi.useFakeTimers();
   vi.setSystemTime(new Date(100_000));
   const h = fixture();
-  const first = renderHook(() => useHiddenDms("community:alice", h.session));
+  const first = renderHook(() =>
+    useHiddenDms("community:alice", h.session, h.list),
+  );
   act(() => first.result.current.hide("dm"));
   first.unmount();
   h.onNextRead(() => h.evidence("offline-message", 98));
-  const restored = renderHook(() => useHiddenDms("community:alice", h.session));
+  const restored = renderHook(() =>
+    useHiddenDms("community:alice", h.session, h.list),
+  );
   await act(async () => {
     await Promise.resolve();
   });
@@ -142,9 +166,65 @@ it("checks a hidden DM directly on return for messages missed while closed", asy
   );
 });
 
+it("waits for the roster before checking a restored DM for missed activity", async () => {
+  const h = fixture();
+  const first = renderHook(() =>
+    useHiddenDms("community:alice", h.session, h.list),
+  );
+  act(() => first.result.current.hide("dm"));
+  first.unmount();
+
+  let list: ChannelList = { status: "idle", channels: [] };
+  h.read.mockClear();
+  h.onNextRead(() => h.evidence("offline-message", 91));
+  const restored = renderHook(() =>
+    useHiddenDms("community:alice", h.session, list),
+  );
+  expect(h.read).not.toHaveBeenCalled();
+  expect(restored.result.current.hiddenIds.has("dm")).toBe(true);
+
+  list = h.list;
+  restored.rerender();
+  await act(async () => {
+    await Promise.resolve();
+  });
+  expect(h.read).toHaveBeenCalledTimes(1);
+  expect(restored.result.current.hiddenIds.has("dm")).toBe(false);
+});
+
+it("does not restore from historical evidence when the head was unknown at hide", async () => {
+  const h = fixture();
+  h.clearHead();
+  h.onNextRead(() => h.evidence("before", 90));
+  const view = renderHook(() =>
+    useHiddenDms("community:alice", h.session, h.list),
+  );
+  act(() => view.result.current.hide("dm"));
+  await act(async () => {
+    await Promise.resolve();
+  });
+  expect(view.result.current.hiddenIds.has("dm")).toBe(true);
+  act(() => h.evidence("new-message", 91));
+  expect(view.result.current.hiddenIds.has("dm")).toBe(false);
+});
+
+it("keeps a DM hidden when deleting its latest message reveals older history", () => {
+  const h = fixture();
+  const view = renderHook(() =>
+    useHiddenDms("community:alice", h.session, h.list),
+  );
+  act(() => view.result.current.hide("dm"));
+  act(() => h.evidence("older", 89));
+  expect(view.result.current.hiddenIds.has("dm")).toBe(true);
+  act(() => h.evidence("new-message", 91));
+  expect(view.result.current.hiddenIds.has("dm")).toBe(false);
+});
+
 it("restores a hidden DM after an outgoing message is delivered", () => {
   const h = fixture();
-  const view = renderHook(() => useHiddenDms("community:alice", h.session));
+  const view = renderHook(() =>
+    useHiddenDms("community:alice", h.session, h.list),
+  );
   act(() => view.result.current.hide("dm"));
   act(() => h.deliver("different"));
   expect(view.result.current.hiddenIds.has("dm")).toBe(true);
@@ -154,7 +234,9 @@ it("restores a hidden DM after an outgoing message is delivered", () => {
 
 it("does not restore a DM hidden again after an older send began", () => {
   const h = fixture();
-  const view = renderHook(() => useHiddenDms("community:alice", h.session));
+  const view = renderHook(() =>
+    useHiddenDms("community:alice", h.session, h.list),
+  );
   act(() => view.result.current.hide("dm"));
   const finish = h.pendingDelivery("dm");
   act(() => view.result.current.hide("dm"));
diff --git a/src/bundled/channels/useHiddenDms.ts b/src/bundled/channels/useHiddenDms.ts
index 5fe6c881b..81b491f50 100644
--- a/src/bundled/channels/useHiddenDms.ts
+++ b/src/bundled/channels/useHiddenDms.ts
@@ -1,32 +1,54 @@
 import { useCallback, useEffect, useRef, useState } from "react";
 import type { RelaySession } from "../../features/relay/session";
+import type { ChannelList } from "../../features/relay/contracts";
 import { readView, writeView } from "../../shared/view-state";
 
-type HiddenDm = { id: string; latestMessageId?: string };
+type MessageHead = Readonly<{ id: string; createdAt: number }>;
+type HiddenDm = { id: string; baseline?: MessageHead | null };
 const key = "hidden-dms";
 
 function restore(scope: string): HiddenDm[] {
   const saved = readView<unknown>(scope, key, []);
   if (!Array.isArray(saved)) return [];
-  return saved.filter(
-    (entry): entry is HiddenDm =>
-      !!entry &&
-      typeof entry === "object" &&
-      typeof entry.id === "string" &&
-      (entry.latestMessageId === undefined ||
-        typeof entry.latestMessageId === "string"),
-  );
+  return saved.flatMap((entry) => {
+    if (!entry || typeof entry !== "object" || typeof entry.id !== "string")
+      return [];
+    const baseline = entry.baseline;
+    return [
+      {
+        id: entry.id,
+        ...(baseline === null ||
+        (baseline &&
+          typeof baseline === "object" &&
+          typeof baseline.id === "string" &&
+          typeof baseline.createdAt === "number" &&
+          Number.isFinite(baseline.createdAt))
+          ? { baseline }
+          : {}),
+      },
+    ];
+  });
 }
 
 /** Local, viewer-scoped sidebar intent; verified message evidence restores a row. */
-export function useHiddenDms(scope: string, session: RelaySession) {
+export function useHiddenDms(
+  scope: string,
+  session: RelaySession,
+  list: ChannelList,
+) {
   const [hidden, setHidden] = useState(() => restore(scope));
   const current = useRef(hidden);
   const update = useCallback(
     (next: HiddenDm[]) => {
       current.current = next;
       setHidden(next);
-      writeView(scope, key, next);
+      // An unresolved baseline is only an optimistic hide; it cannot be
+      // recovered safely after closing before its first verified head read.
+      writeView(
+        scope,
+        key,
+        next.filter((entry) => entry.baseline !== undefined),
+      );
     },
     [scope],
   );
@@ -48,7 +70,7 @@ export function useHiddenDms(scope: string, session: RelaySession) {
         ...current.current.filter((entry) => entry.id !== id),
         {
           id,
-          ...(latest ? { latestMessageId: latest.id } : {}),
+          ...(latest ? { baseline: latest } : {}),
         },
       ]);
     },
@@ -58,14 +80,28 @@ export function useHiddenDms(scope: string, session: RelaySession) {
   useEffect(() => {
     if (!hidden.length) return;
     const check = () => {
-      const resurfaced = current.current.flatMap((entry) => {
+      const next = current.current.flatMap((entry) => {
         const latest = session.unread.snapshot({
           kind: "channel",
           channelId: entry.id,
         }).latestMessage;
-        return latest && latest.id !== entry.latestMessageId ? [entry.id] : [];
+        if (!latest || entry.baseline === undefined) return [entry];
+        if (entry.baseline === null) return [];
+        if (latest.id === entry.baseline.id) return [entry];
+        if (
+          latest.createdAt > entry.baseline.createdAt ||
+          (latest.createdAt === entry.baseline.createdAt &&
+            latest.id < entry.baseline.id)
+        )
+          return [];
+        // A deletion can reveal an older head. Keep hiding from that head.
+        return [{ ...entry, baseline: latest }];
       });
-      if (resurfaced.length) show(resurfaced);
+      if (
+        next.length !== current.current.length ||
+        next.some((entry, index) => entry !== current.current[index])
+      )
+        update(next);
     };
     const stops = hidden.map((entry) =>
       session.unread.subscribe({ kind: "channel", channelId: entry.id }, check),
@@ -89,32 +125,42 @@ export function useHiddenDms(scope: string, session: RelaySession) {
       stopIncoming();
       stopOutgoing?.();
     };
-  }, [hidden, session, show]);
+  }, [hidden, session, show, update]);
 
   useEffect(() => {
-    if (!hidden.length) return;
+    if (!hidden.length || list.status !== "ready") return;
     const controller = new AbortController();
     // The shared unread repair is roster-wide and capped. Check each hidden DM's
     // latest verified message so an offline arrival can restore it on return.
     void (async () => {
-      for (const { id } of hidden) {
+      for (const entry of hidden) {
         if (controller.signal.aborted) return;
-        const channel = session.channels
-          .list()
-          .channels.find((item) => item.id === id);
+        const { id } = entry;
+        const channel = list.channels.find((item) => item.id === id);
         if (channel?.channelType !== "dm") continue;
         try {
           await session.read([{ kinds: [9, 40002], "#h": [id], limit: 1 }], {
             signal: controller.signal,
             priority: "background",
           });
+          if (entry.baseline === undefined && current.current.includes(entry)) {
+            const latest = session.unread.snapshot({
+              kind: "channel",
+              channelId: id,
+            }).latestMessage;
+            update(
+              current.current.map((item) =>
+                item === entry ? { ...item, baseline: latest ?? null } : item,
+              ),
+            );
+          }
         } catch {
           // Live delivery and a later mount can still restore the row.
         }
       }
     })();
     return () => controller.abort();
-  }, [hidden, session]);
+  }, [hidden, session, list, update]);
 
   return { hiddenIds: new Set(hidden.map((entry) => entry.id)), hide };
 }

From acb4377f54e38727a31464ac6c69ca5949e5f393 Mon Sep 17 00:00:00 2001
From: klopez4212 <klopez4212@gmail.com>
Date: Wed, 23 Sep 2026 14:22:33 +0100
Subject: [PATCH 4/8] fix(channels): recover hidden DMs across late activity

Signed-off-by: klopez4212 <klopez4212@gmail.com>
---
 src/bundled/channels/ChannelSidebarRow.tsx |  18 +++-
 src/bundled/channels/useHiddenDms.test.tsx |  85 ++++++++++++++-
 src/bundled/channels/useHiddenDms.ts       | 119 +++++++++++++++------
 tests/browser/sidebar-unread.spec.mjs      |   3 +
 4 files changed, 188 insertions(+), 37 deletions(-)

diff --git a/src/bundled/channels/ChannelSidebarRow.tsx b/src/bundled/channels/ChannelSidebarRow.tsx
index c4bb4a469..7e36ab2d0 100644
--- a/src/bundled/channels/ChannelSidebarRow.tsx
+++ b/src/bundled/channels/ChannelSidebarRow.tsx
@@ -172,7 +172,23 @@ export function ChannelSidebarRow({
               size="compact"
               shape="round"
               aria-label={`Remove ${channel.name} from DMs`}
-              onClick={() => onHideDm(channel.id)}
+              onClick={(event) => {
+                const section = event.currentTarget.closest("details");
+                const rows = [
+                  ...(section?.querySelectorAll<HTMLElement>(
+                    "button[data-channel-id]",
+                  ) ?? []),
+                ];
+                const index = rows.findIndex(
+                  (row) => row.dataset.channelId === channel.id,
+                );
+                (
+                  rows[index + 1] ??
+                  rows[index - 1] ??
+                  section?.querySelector<HTMLElement>("summary")
+                )?.focus();
+                onHideDm(channel.id);
+              }}
               icon={<XIcon size={15} aria-hidden="true" />}
             />
           </span>
diff --git a/src/bundled/channels/useHiddenDms.test.tsx b/src/bundled/channels/useHiddenDms.test.tsx
index 88f21c79c..7d07452c2 100644
--- a/src/bundled/channels/useHiddenDms.test.tsx
+++ b/src/bundled/channels/useHiddenDms.test.tsx
@@ -4,6 +4,7 @@ import { afterEach, expect, it, vi } from "vitest";
 import type { RelaySession } from "../../features/relay/session";
 import type { IncomingListener } from "../../features/relay/incoming";
 import type { ChannelList } from "../../features/relay/contracts";
+import { readView } from "../../shared/view-state";
 import { useHiddenDms } from "./useHiddenDms";
 
 afterEach(() => {
@@ -30,9 +31,15 @@ function fixture() {
   >[0];
   const outgoing = new Set<ObserveSend>();
   let onRead = () => {};
+  let historyIds = ["before"];
+  let failures = 0;
   const read = vi.fn(async () => {
+    if (failures > 0) {
+      failures--;
+      throw new Error("Temporary relay failure");
+    }
     onRead();
-    return [];
+    return historyIds.map((id) => ({ id }));
   });
   const session = {
     channels: {
@@ -66,6 +73,12 @@ function fixture() {
     onNextRead(callback: () => void) {
       onRead = callback;
     },
+    history(ids: string[]) {
+      historyIds = ids;
+    },
+    failNextRead() {
+      failures++;
+    },
     evidence(id: string, createdAt: number) {
       latest = { id, createdAt };
       for (const listener of listeners) listener();
@@ -161,7 +174,7 @@ it("checks a hidden DM directly on return for messages missed while closed", asy
   });
   expect(restored.result.current.hiddenIds.has("dm")).toBe(false);
   expect(h.read).toHaveBeenCalledWith(
-    [{ kinds: [9, 40002], "#h": ["dm"], limit: 1 }],
+    [{ kinds: [9, 40002], "#h": ["dm"], limit: 50 }],
     expect.objectContaining({ priority: "background" }),
   );
 });
@@ -208,16 +221,80 @@ it("does not restore from historical evidence when the head was unknown at hide"
   expect(view.result.current.hiddenIds.has("dm")).toBe(false);
 });
 
-it("keeps a DM hidden when deleting its latest message reveals older history", () => {
+it("persists a hide while its first baseline read is pending", () => {
   const h = fixture();
+  h.clearHead();
   const view = renderHook(() =>
     useHiddenDms("community:alice", h.session, h.list),
   );
   act(() => view.result.current.hide("dm"));
+  expect(view.result.current.hiddenIds.has("dm")).toBe(true);
+  expect(readView("community:alice", "hidden-dms", [])).toEqual([{ id: "dm" }]);
+  view.unmount();
+  const restored = renderHook(() =>
+    useHiddenDms("community:alice", h.session, h.list),
+  );
+  expect(restored.result.current.hiddenIds.has("dm")).toBe(true);
+});
+
+it("restores for an offline message that sorts behind the previous head", async () => {
+  const h = fixture();
+  const first = renderHook(() =>
+    useHiddenDms("community:alice", h.session, h.list),
+  );
+  act(() => first.result.current.hide("dm"));
+  await act(async () => {
+    await Promise.resolve();
+  });
+  first.unmount();
+  h.history(["before", "late-old"]);
+  const restored = renderHook(() =>
+    useHiddenDms("community:alice", h.session, h.list),
+  );
+  await act(async () => {
+    await Promise.resolve();
+  });
+  expect(restored.result.current.hiddenIds.has("dm")).toBe(false);
+});
+
+it("retries a transient hidden-DM history failure", async () => {
+  vi.useFakeTimers();
+  const h = fixture();
+  h.failNextRead();
+  const view = renderHook(() =>
+    useHiddenDms("community:alice", h.session, h.list),
+  );
+  act(() => view.result.current.hide("dm"));
+  expect(h.read).toHaveBeenCalledTimes(1);
+  await act(async () => {
+    await vi.advanceTimersByTimeAsync(500);
+  });
+  expect(h.read).toHaveBeenCalledTimes(2);
+  expect(view.result.current.hiddenIds.has("dm")).toBe(true);
+});
+
+it("keeps a DM hidden when deleting its latest message reveals older history", async () => {
+  const h = fixture();
+  const view = renderHook(() =>
+    useHiddenDms("community:alice", h.session, h.list),
+  );
+  act(() => view.result.current.hide("dm"));
+  await act(async () => {
+    await Promise.resolve();
+  });
   act(() => h.evidence("older", 89));
   expect(view.result.current.hiddenIds.has("dm")).toBe(true);
+  view.unmount();
+  h.history(["older"]);
+  const restored = renderHook(() =>
+    useHiddenDms("community:alice", h.session, h.list),
+  );
+  await act(async () => {
+    await Promise.resolve();
+  });
+  expect(restored.result.current.hiddenIds.has("dm")).toBe(true);
   act(() => h.evidence("new-message", 91));
-  expect(view.result.current.hiddenIds.has("dm")).toBe(false);
+  expect(restored.result.current.hiddenIds.has("dm")).toBe(false);
 });
 
 it("restores a hidden DM after an outgoing message is delivered", () => {
diff --git a/src/bundled/channels/useHiddenDms.ts b/src/bundled/channels/useHiddenDms.ts
index 81b491f50..e33b9c708 100644
--- a/src/bundled/channels/useHiddenDms.ts
+++ b/src/bundled/channels/useHiddenDms.ts
@@ -4,9 +4,26 @@ import type { ChannelList } from "../../features/relay/contracts";
 import { readView, writeView } from "../../shared/view-state";
 
 type MessageHead = Readonly<{ id: string; createdAt: number }>;
-type HiddenDm = { id: string; baseline?: MessageHead | null };
+type HiddenDm = {
+  id: string;
+  baseline?: MessageHead | null;
+  knownIds?: readonly string[];
+};
 const key = "hidden-dms";
 
+function pause(ms: number, signal: AbortSignal): Promise<void> {
+  return new Promise((resolve) => {
+    if (signal.aborted) return resolve();
+    const done = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", done);
+      resolve();
+    };
+    const timer = setTimeout(done, ms);
+    signal.addEventListener("abort", done, { once: true });
+  });
+}
+
 function restore(scope: string): HiddenDm[] {
   const saved = readView<unknown>(scope, key, []);
   if (!Array.isArray(saved)) return [];
@@ -14,6 +31,7 @@ function restore(scope: string): HiddenDm[] {
     if (!entry || typeof entry !== "object" || typeof entry.id !== "string")
       return [];
     const baseline = entry.baseline;
+    const knownIds = entry.knownIds;
     return [
       {
         id: entry.id,
@@ -25,6 +43,10 @@ function restore(scope: string): HiddenDm[] {
           Number.isFinite(baseline.createdAt))
           ? { baseline }
           : {}),
+        ...(Array.isArray(knownIds) &&
+        knownIds.every((id): id is string => typeof id === "string")
+          ? { knownIds }
+          : {}),
       },
     ];
   });
@@ -37,18 +59,13 @@ export function useHiddenDms(
   list: ChannelList,
 ) {
   const [hidden, setHidden] = useState(() => restore(scope));
+  const hiddenKey = hidden.map((entry) => entry.id).join("\u0000");
   const current = useRef(hidden);
   const update = useCallback(
     (next: HiddenDm[]) => {
       current.current = next;
       setHidden(next);
-      // An unresolved baseline is only an optimistic hide; it cannot be
-      // recovered safely after closing before its first verified head read.
-      writeView(
-        scope,
-        key,
-        next.filter((entry) => entry.baseline !== undefined),
-      );
+      writeView(scope, key, next);
     },
     [scope],
   );
@@ -94,8 +111,9 @@ export function useHiddenDms(
             latest.id < entry.baseline.id)
         )
           return [];
-        // A deletion can reveal an older head. Keep hiding from that head.
-        return [{ ...entry, baseline: latest }];
+        // The direct history read can distinguish an older arrival from a
+        // deletion that exposed old history. A head rollback alone cannot.
+        return [entry];
       });
       if (
         next.length !== current.current.length ||
@@ -128,39 +146,76 @@ export function useHiddenDms(
   }, [hidden, session, show, update]);
 
   useEffect(() => {
-    if (!hidden.length || list.status !== "ready") return;
+    if (!hiddenKey || list.status !== "ready") return;
     const controller = new AbortController();
-    // The shared unread repair is roster-wide and capped. Check each hidden DM's
-    // latest verified message so an offline arrival can restore it on return.
+    // The shared unread repair is roster-wide and capped. Compare a bounded
+    // per-DM history window so a late-arriving message need not be the head.
     void (async () => {
-      for (const entry of hidden) {
+      for (const id of hiddenKey.split("\u0000")) {
         if (controller.signal.aborted) return;
-        const { id } = entry;
+        const entry = current.current.find((item) => item.id === id);
+        if (!entry) continue;
         const channel = list.channels.find((item) => item.id === id);
         if (channel?.channelType !== "dm") continue;
-        try {
-          await session.read([{ kinds: [9, 40002], "#h": [id], limit: 1 }], {
-            signal: controller.signal,
-            priority: "background",
-          });
-          if (entry.baseline === undefined && current.current.includes(entry)) {
-            const latest = session.unread.snapshot({
-              kind: "channel",
-              channelId: id,
-            }).latestMessage;
-            update(
-              current.current.map((item) =>
-                item === entry ? { ...item, baseline: latest ?? null } : item,
-              ),
+        for (
+          let attempt = 0;
+          attempt < 3 && !controller.signal.aborted;
+          attempt++
+        ) {
+          try {
+            const events = await session.read(
+              [{ kinds: [9, 40002], "#h": [id], limit: 50 }],
+              {
+                signal: controller.signal,
+                priority: "background",
+              },
             );
+            if (current.current.includes(entry)) {
+              const latest = session.unread.snapshot({
+                kind: "channel",
+                channelId: id,
+              }).latestMessage;
+              const ids = events.map((event) => event.id);
+              const changed =
+                entry.knownIds &&
+                ids.some((eventId) => !entry.knownIds?.includes(eventId));
+              const deletedHead =
+                entry.baseline &&
+                !ids.includes(entry.baseline.id) &&
+                latest &&
+                (latest.createdAt < entry.baseline.createdAt ||
+                  (latest.createdAt === entry.baseline.createdAt &&
+                    latest.id > entry.baseline.id));
+              if (changed && !deletedHead) {
+                show([id]);
+                break;
+              }
+              if (
+                entry.baseline === undefined ||
+                !entry.knownIds ||
+                deletedHead
+              )
+                update(
+                  current.current.map((item) =>
+                    item === entry
+                      ? {
+                          ...item,
+                          baseline: latest ?? null,
+                          knownIds: ids,
+                        }
+                      : item,
+                  ),
+                );
+            }
+            break;
+          } catch {
+            if (attempt < 2) await pause(500 * 2 ** attempt, controller.signal);
           }
-        } catch {
-          // Live delivery and a later mount can still restore the row.
         }
       }
     })();
     return () => controller.abort();
-  }, [hidden, session, list, update]);
+  }, [hiddenKey, session, list, show, update]);
 
   return { hiddenIds: new Set(hidden.map((entry) => entry.id)), hide };
 }
diff --git a/tests/browser/sidebar-unread.spec.mjs b/tests/browser/sidebar-unread.spec.mjs
index 8c1be4dc9..f2c1b4b18 100644
--- a/tests/browser/sidebar-unread.spec.mjs
+++ b/tests/browser/sidebar-unread.spec.mjs
@@ -96,6 +96,9 @@ test("DM hide control removes a row and a new message restores it", async ({
     .toBe(primary);
   await hide.click();
   await expect(dm).toHaveCount(0);
+  await expect(list(page).locator("button[data-channel-id]:focus")).toHaveCount(
+    1,
+  );
   await page.reload();
   await expect(row(page, "dm-031")).toBeVisible();
   await expect(dm).toHaveCount(0);

From 934466e28cc090e235302692aabc25372992ab6b Mon Sep 17 00:00:00 2001
From: klopez4212 <klopez4212@gmail.com>
Date: Wed, 23 Sep 2026 14:36:48 +0100
Subject: [PATCH 5/8] fix(channels): bound hidden DM checks to roster changes

Signed-off-by: klopez4212 <klopez4212@gmail.com>
---
 src/bundled/channels/useHiddenDms.test.tsx | 77 +++++++++++++++++++++-
 src/bundled/channels/useHiddenDms.ts       | 41 +++++++-----
 2 files changed, 97 insertions(+), 21 deletions(-)

diff --git a/src/bundled/channels/useHiddenDms.test.tsx b/src/bundled/channels/useHiddenDms.test.tsx
index 7d07452c2..8f76dfe8c 100644
--- a/src/bundled/channels/useHiddenDms.test.tsx
+++ b/src/bundled/channels/useHiddenDms.test.tsx
@@ -33,13 +33,13 @@ function fixture() {
   let onRead = () => {};
   let historyIds = ["before"];
   let failures = 0;
-  const read = vi.fn(async () => {
+  const read = vi.fn(async (filters: readonly { limit: number }[]) => {
     if (failures > 0) {
       failures--;
       throw new Error("Temporary relay failure");
     }
     onRead();
-    return historyIds.map((id) => ({ id }));
+    return historyIds.slice(0, filters[0]?.limit).map((id) => ({ id }));
   });
   const session = {
     channels: {
@@ -174,7 +174,7 @@ it("checks a hidden DM directly on return for messages missed while closed", asy
   });
   expect(restored.result.current.hiddenIds.has("dm")).toBe(false);
   expect(h.read).toHaveBeenCalledWith(
-    [{ kinds: [9, 40002], "#h": ["dm"], limit: 50 }],
+    [{ kinds: [9, 40002], "#h": ["dm"], limit: 100 }],
     expect.objectContaining({ priority: "background" }),
   );
 });
@@ -205,6 +205,28 @@ it("waits for the roster before checking a restored DM for missed activity", asy
   expect(restored.result.current.hiddenIds.has("dm")).toBe(false);
 });
 
+it("does not restart hidden history reads for a preview-only roster update", async () => {
+  const h = fixture();
+  let list = h.list;
+  const view = renderHook(() =>
+    useHiddenDms("community:alice", h.session, list),
+  );
+  act(() => view.result.current.hide("dm"));
+  await act(async () => {
+    await Promise.resolve();
+  });
+  h.read.mockClear();
+  list = {
+    ...h.list,
+    channels: h.list.channels.map((channel) => ({
+      ...channel,
+      preview: "changed",
+    })),
+  };
+  view.rerender();
+  expect(h.read).not.toHaveBeenCalled();
+});
+
 it("does not restore from historical evidence when the head was unknown at hide", async () => {
   const h = fixture();
   h.clearHead();
@@ -275,6 +297,7 @@ it("retries a transient hidden-DM history failure", async () => {
 
 it("keeps a DM hidden when deleting its latest message reveals older history", async () => {
   const h = fixture();
+  h.history(["before", "older"]);
   const view = renderHook(() =>
     useHiddenDms("community:alice", h.session, h.list),
   );
@@ -297,6 +320,54 @@ it("keeps a DM hidden when deleting its latest message reveals older history", a
   expect(restored.result.current.hiddenIds.has("dm")).toBe(false);
 });
 
+it("restores when a deleted head and a late message appear together", async () => {
+  const h = fixture();
+  h.history(["before", "older"]);
+  const first = renderHook(() =>
+    useHiddenDms("community:alice", h.session, h.list),
+  );
+  act(() => first.result.current.hide("dm"));
+  await act(async () => {
+    await Promise.resolve();
+  });
+  first.unmount();
+  h.history(["older", "late-old"]);
+  h.evidence("older", 89);
+  const restored = renderHook(() =>
+    useHiddenDms("community:alice", h.session, h.list),
+  );
+  await act(async () => {
+    await Promise.resolve();
+  });
+  expect(restored.result.current.hiddenIds.has("dm")).toBe(false);
+});
+
+it("keeps a DM hidden when deletion slides the read window back", async () => {
+  const h = fixture();
+  const history = [
+    "before",
+    ...Array.from({ length: 99 }, (_, i) => `older-${i}`),
+  ];
+  h.history(history);
+  const first = renderHook(() =>
+    useHiddenDms("community:alice", h.session, h.list),
+  );
+  act(() => first.result.current.hide("dm"));
+  await act(async () => {
+    await Promise.resolve();
+  });
+  first.unmount();
+  h.history(history.slice(1));
+  h.evidence("older-0", 89);
+  const restored = renderHook(() =>
+    useHiddenDms("community:alice", h.session, h.list),
+  );
+  await act(async () => {
+    await Promise.resolve();
+  });
+  expect(restored.result.current.hiddenIds.has("dm")).toBe(true);
+});
+
 it("restores a hidden DM after an outgoing message is delivered", () => {
   const h = fixture();
   const view = renderHook(() =>
diff --git a/src/bundled/channels/useHiddenDms.ts b/src/bundled/channels/useHiddenDms.ts
index e33b9c708..86267a8ca 100644
--- a/src/bundled/channels/useHiddenDms.ts
+++ b/src/bundled/channels/useHiddenDms.ts
@@ -60,6 +60,14 @@ export function useHiddenDms(
 ) {
   const [hidden, setHidden] = useState(() => restore(scope));
   const hiddenKey = hidden.map((entry) => entry.id).join("\u0000");
+  const dmRosterKey =
+    list.status === "ready"
+      ? list.channels
+          .filter((channel) => channel.channelType === "dm")
+          .map((channel) => channel.id)
+          .sort()
+          .join("\u0000")
+      : "";
   const current = useRef(hidden);
   const update = useCallback(
     (next: HiddenDm[]) => {
@@ -146,8 +154,9 @@ export function useHiddenDms(
   }, [hidden, session, show, update]);
 
   useEffect(() => {
-    if (!hiddenKey || list.status !== "ready") return;
+    if (!hiddenKey || !dmRosterKey) return;
     const controller = new AbortController();
+    const dmIds = new Set(dmRosterKey.split("\u0000"));
     // The shared unread repair is roster-wide and capped. Compare a bounded
     // per-DM history window so a late-arriving message need not be the head.
     void (async () => {
@@ -155,16 +164,23 @@ export function useHiddenDms(
         if (controller.signal.aborted) return;
         const entry = current.current.find((item) => item.id === id);
         if (!entry) continue;
-        const channel = list.channels.find((item) => item.id === id);
-        if (channel?.channelType !== "dm") continue;
+        if (!dmIds.has(id)) continue;
         for (
           let attempt = 0;
           attempt < 3 && !controller.signal.aborted;
           attempt++
         ) {
           try {
+            // Save a deeper initial window so deleting a recent head does not
+            // make older pre-hide history look like a new message.
             const events = await session.read(
-              [{ kinds: [9, 40002], "#h": [id], limit: 50 }],
+              [
+                {
+                  kinds: [9, 40002],
+                  "#h": [id],
+                  limit: entry.knownIds ? 50 : 100,
+                },
+              ],
               {
                 signal: controller.signal,
                 priority: "background",
@@ -179,22 +195,11 @@ export function useHiddenDms(
               const changed =
                 entry.knownIds &&
                 ids.some((eventId) => !entry.knownIds?.includes(eventId));
-              const deletedHead =
-                entry.baseline &&
-                !ids.includes(entry.baseline.id) &&
-                latest &&
-                (latest.createdAt < entry.baseline.createdAt ||
-                  (latest.createdAt === entry.baseline.createdAt &&
-                    latest.id > entry.baseline.id));
-              if (changed && !deletedHead) {
+              if (changed) {
                 show([id]);
                 break;
               }
-              if (
-                entry.baseline === undefined ||
-                !entry.knownIds ||
-                deletedHead
-              )
+              if (entry.baseline === undefined || !entry.knownIds)
                 update(
                   current.current.map((item) =>
                     item === entry
@@ -215,7 +220,7 @@ export function useHiddenDms(
       }
     })();
     return () => controller.abort();
-  }, [hiddenKey, session, list, show, update]);
+  }, [hiddenKey, session, dmRosterKey, show, update]);
 
   return { hiddenIds: new Set(hidden.map((entry) => entry.id)), hide };
 }

From 225dfecf943434b048764815651cca2566109736 Mon Sep 17 00:00:00 2001
From: klopez4212 <klopez4212@gmail.com>
Date: Wed, 23 Sep 2026 14:48:55 +0100
Subject: [PATCH 6/8] fix(channels): keep focus after hiding the last DM

Signed-off-by: klopez4212 <klopez4212@gmail.com>
---
 .../channels/ChannelSidebarRow.test.tsx       | 37 +++++++++++++++++++
 src/bundled/channels/ChannelSidebarRow.tsx    | 11 +++---
 2 files changed, 43 insertions(+), 5 deletions(-)

diff --git a/src/bundled/channels/ChannelSidebarRow.test.tsx b/src/bundled/channels/ChannelSidebarRow.test.tsx
index e2df9a6b5..ad63a91b1 100644
--- a/src/bundled/channels/ChannelSidebarRow.test.tsx
+++ b/src/bundled/channels/ChannelSidebarRow.test.tsx
@@ -165,6 +165,43 @@ it("offers a separate hide action only for DM rows", async () => {
   expect(onHideDm).toHaveBeenCalledWith("dm");
   expect(onSelect).not.toHaveBeenCalled();
 });
+it("keeps focus in the sidebar when removing its last visible DM", async () => {
+  function OnlyDm() {
+    const [visible, setVisible] = useState(true);
+    return (
+      <div>
+        <details open>
+          <summary>Channels</summary>
+        </details>
+        {visible && (
+          <details open>
+            <summary>DMs</summary>
+            <ChannelSidebarRow
+              channel={{ id: "dm", name: "Alice", channelType: "dm" }}
+              collapsed={false}
+              onToggle={() => {}}
+              icon={<svg />}
+              sessions={[]}
+              sessionsEnabled={false}
+              draft={false}
+              draftSelected={false}
+              onSelect={() => {}}
+              onPrepare={() => {}}
+              onNewSession={() => {}}
+              onHideDm={() => setVisible(false)}
+            />
+          </details>
+        )}
+      </div>
+    );
+  }
+  render(<OnlyDm />);
+  const remove = screen.getByRole("button", { name: "Remove Alice from DMs" });
+  remove.focus();
+  await userEvent.setup().keyboard("{Enter}");
+  expect(screen.queryByText("DMs")).not.toBeInTheDocument();
+  expect(screen.getByText("Channels")).toHaveFocus();
+});
 it("opens saved child sessions and retained drafts without a channel icon", async () => {
   const user = userEvent.setup();
   const callbacks = mount();
diff --git a/src/bundled/channels/ChannelSidebarRow.tsx b/src/bundled/channels/ChannelSidebarRow.tsx
index 7e36ab2d0..0c90b58b2 100644
--- a/src/bundled/channels/ChannelSidebarRow.tsx
+++ b/src/bundled/channels/ChannelSidebarRow.tsx
@@ -182,11 +182,12 @@ export function ChannelSidebarRow({
                 const index = rows.findIndex(
                   (row) => row.dataset.channelId === channel.id,
                 );
-                (
-                  rows[index + 1] ??
-                  rows[index - 1] ??
-                  section?.querySelector<HTMLElement>("summary")
-                )?.focus();
+                const otherSection = [
+                  ...(section?.parentElement?.querySelectorAll<HTMLElement>(
+                    "details > summary",
+                  ) ?? []),
+                ].find((summary) => summary.parentElement !== section);
+                (rows[index + 1] ?? rows[index - 1] ?? otherSection)?.focus();
                 onHideDm(channel.id);
               }}
               icon={<XIcon size={15} aria-hidden="true" />}

From 34e9b11d135aa44875a2fee8190f79d8bb28daf2 Mon Sep 17 00:00:00 2001
From: klopez4212 <klopez4212@gmail.com>
Date: Wed, 23 Sep 2026 16:27:19 +0100
Subject: [PATCH 7/8] fix(channels): preserve DM hide generation through
 enrichment

Signed-off-by: klopez4212 <klopez4212@gmail.com>
---
 src/bundled/channels/useHiddenDms.test.tsx | 50 +++++++++++++++++++++-
 src/bundled/channels/useHiddenDms.ts       |  8 +++-
 2 files changed, 56 insertions(+), 2 deletions(-)

diff --git a/src/bundled/channels/useHiddenDms.test.tsx b/src/bundled/channels/useHiddenDms.test.tsx
index 8f76dfe8c..f554a29a8 100644
--- a/src/bundled/channels/useHiddenDms.test.tsx
+++ b/src/bundled/channels/useHiddenDms.test.tsx
@@ -31,6 +31,7 @@ function fixture() {
   >[0];
   const outgoing = new Set<ObserveSend>();
   let onRead = () => {};
+  let nextRead: Promise<void> | undefined;
   let historyIds = ["before"];
   let failures = 0;
   const read = vi.fn(async (filters: readonly { limit: number }[]) => {
@@ -39,6 +40,9 @@ function fixture() {
       throw new Error("Temporary relay failure");
     }
     onRead();
+    const held = nextRead;
+    nextRead = undefined;
+    if (held) await held;
     return historyIds.slice(0, filters[0]?.limit).map((id) => ({ id }));
   });
   const session = {
@@ -73,6 +77,13 @@ function fixture() {
     onNextRead(callback: () => void) {
       onRead = callback;
     },
+    holdNextRead() {
+      let release = () => {};
+      nextRead = new Promise<void>((resolve) => {
+        release = resolve;
+      });
+      return () => release();
+    },
     history(ids: string[]) {
       historyIds = ids;
     },
@@ -380,13 +391,50 @@ it("restores a hidden DM after an outgoing message is delivered", () => {
   expect(view.result.current.hiddenIds.has("dm")).toBe(false);
 });
 
-it("does not restore a DM hidden again after an older send began", () => {
+it("restores an outgoing send after history enrichment without head advancement", async () => {
+  const h = fixture();
+  const release = h.holdNextRead();
+  const view = renderHook(() =>
+    useHiddenDms("community:alice", h.session, h.list),
+  );
+  act(() => view.result.current.hide("dm"));
+  expect(h.read).toHaveBeenCalledTimes(1);
+  const finish = h.pendingDelivery("dm");
+
+  await act(async () => {
+    release();
+    await Promise.resolve();
+  });
+  expect(readView("community:alice", "hidden-dms", [])).toEqual([
+    {
+      id: "dm",
+      baseline: { id: "before", createdAt: 90 },
+      knownIds: ["before"],
+    },
+  ]);
+  expect(view.result.current.hiddenIds.has("dm")).toBe(true);
+
+  act(() => finish?.([]));
+  expect(
+    h.session.unread.snapshot({ kind: "channel", channelId: "dm" })
+      .latestMessage,
+  ).toEqual({ id: "before", createdAt: 90 });
+  expect(view.result.current.hiddenIds.has("dm")).toBe(false);
+});
+
+it("does not restore a DM hidden again after an older send began", async () => {
   const h = fixture();
+  const release = h.holdNextRead();
   const view = renderHook(() =>
     useHiddenDms("community:alice", h.session, h.list),
   );
   act(() => view.result.current.hide("dm"));
   const finish = h.pendingDelivery("dm");
+  expect(finish).toBeTypeOf("function");
+  await act(async () => {
+    release();
+    await Promise.resolve();
+  });
   act(() => view.result.current.hide("dm"));
   act(() => finish?.([]));
   expect(view.result.current.hiddenIds.has("dm")).toBe(true);
diff --git a/src/bundled/channels/useHiddenDms.ts b/src/bundled/channels/useHiddenDms.ts
index 86267a8ca..d2b8f24c3 100644
--- a/src/bundled/channels/useHiddenDms.ts
+++ b/src/bundled/channels/useHiddenDms.ts
@@ -6,6 +6,8 @@ import { readView, writeView } from "../../shared/view-state";
 type MessageHead = Readonly<{ id: string; createdAt: number }>;
 type HiddenDm = {
   id: string;
+  // Keeps one hide identifiable through enrichment; JSON persistence omits it.
+  hideGeneration: symbol;
   baseline?: MessageHead | null;
   knownIds?: readonly string[];
 };
@@ -35,6 +37,7 @@ function restore(scope: string): HiddenDm[] {
     return [
       {
         id: entry.id,
+        hideGeneration: Symbol(),
         ...(baseline === null ||
         (baseline &&
           typeof baseline === "object" &&
@@ -95,6 +98,7 @@ export function useHiddenDms(
         ...current.current.filter((entry) => entry.id !== id),
         {
           id,
+          hideGeneration: Symbol(),
           ...(latest ? { baseline: latest } : {}),
         },
       ]);
@@ -142,7 +146,9 @@ export function useHiddenDms(
       const hiddenAtSend = current.current.find((entry) => entry.id === id);
       if (!id || !hiddenAtSend) return;
       return () => {
-        if (current.current.includes(hiddenAtSend)) show([id]);
+        const hiddenNow = current.current.find((entry) => entry.id === id);
+        if (hiddenNow?.hideGeneration === hiddenAtSend.hideGeneration)
+          show([id]);
       };
     });
     check();

From bbb96c0f9226e1548f4330034eae8d0f7a9bb758 Mon Sep 17 00:00:00 2001
From: klopez4212 <klopez4212@gmail.com>
Date: Wed, 23 Sep 2026 17:25:24 +0100
Subject: [PATCH 8/8] test(browser): follow channel settings in quota recovery

Signed-off-by: klopez4212 <klopez4212@gmail.com>
---
 tests/browser/live-status.spec.mjs | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/tests/browser/live-status.spec.mjs b/tests/browser/live-status.spec.mjs
index 6bb43bcf9..2f088cc54 100644
--- a/tests/browser/live-status.spec.mjs
+++ b/tests/browser/live-status.spec.mjs
@@ -146,7 +146,9 @@ for (const target of ["alpha", "profiles"]) {
     // Persistent feedback must not block the header, composer, or narrow navigation.
     for (const width of [390, 800, 1440]) {
       await page.setViewportSize({ width, height: 950 });
-      await page.getByLabel("Conversation options", { exact: true }).click();
+      await page
+        .getByRole("button", { name: "Close channel settings", exact: true })
+        .click();
       await page
         .getByRole("textbox", { name: "Message #Alpha", exact: true })
         .fill("Unsent recovery draft");
@@ -155,11 +157,13 @@ for (const target of ["alpha", "profiles"]) {
       await page.screenshot({
         path: testInfo.outputPath(`toast-app-${target}-${width}.png`),
       });
-      await page.getByLabel("Conversation options", { exact: true }).click();
+      await page
+        .getByRole("button", { name: "Channel settings", exact: true })
+        .click();
     }
     const beforeManual = requests().length;
     await page
-      .getByRole("button", { name: "Channel settings", exact: true })
+      .getByRole("button", { name: "Close channel settings", exact: true })
       .click();
     await page
       .getByRole("button", { name: "Retry live updates", exact: true })