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..ad63a91b1 100644
--- a/src/bundled/channels/ChannelSidebarRow.test.tsx
+++ b/src/bundled/channels/ChannelSidebarRow.test.tsx
@@ -138,6 +138,70 @@ 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("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 2d372f705..0c90b58b2 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,35 @@ 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={(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,
+                );
+                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" />}
+            />
+          </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 698b95e10..badf98ab3 100644
--- a/src/bundled/channels/ChannelsPage.tsx
+++ b/src/bundled/channels/ChannelsPage.tsx
@@ -65,6 +65,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,
@@ -199,6 +200,7 @@ function ChannelWorkspace({
       .map((entry) => entry.channelId),
   ]);
   const preferences = useSidebarPreferences(queries.sidebarPreferences);
+  const hiddenDms = useHiddenDms(scope, queries, list);
   useEffect(() => {
     void queries.emoji.ensure();
   }, [queries]);
@@ -798,6 +800,11 @@ function ChannelWorkspace({
   const drawer = useChannelPanels(panels, drawerContext, () =>
     setSettings(undefined),
   );
+  const sections = sidebarSections(
+    channels,
+    preferences.data,
+    hiddenDms.hiddenIds,
+  );
   return (
     <div
       className={`${styles.board} ${showingSettings || panel || showingThread || companion ? styles.withPanel : ""}`}
@@ -810,7 +817,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
@@ -889,6 +896,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..f554a29a8
--- /dev/null
+++ b/src/bundled/channels/useHiddenDms.test.tsx
@@ -0,0 +1,441 @@
+// @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 type { ChannelList } from "../../features/relay/contracts";
+import { readView } from "../../shared/view-state";
+import { useHiddenDms } from "./useHiddenDms";
+
+afterEach(() => {
+  cleanup();
+  localStorage.clear();
+  vi.useRealTimers();
+});
+
+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,
+  };
+  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 = () => {};
+  let nextRead: Promise<void> | undefined;
+  let historyIds = ["before"];
+  let failures = 0;
+  const read = vi.fn(async (filters: readonly { limit: number }[]) => {
+    if (failures > 0) {
+      failures--;
+      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 = {
+    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,
+    list,
+    read,
+    onNextRead(callback: () => void) {
+      onRead = callback;
+    },
+    holdNextRead() {
+      let release = () => {};
+      nextRead = new Promise<void>((resolve) => {
+        release = resolve;
+      });
+      return () => release();
+    },
+    history(ids: string[]) {
+      historyIds = ids;
+    },
+    failNextRead() {
+      failures++;
+    },
+    evidence(id: string, createdAt: number) {
+      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([
+          {
+            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, 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, h.list),
+  );
+  expect(restored.result.current.hiddenIds.has("dm")).toBe(true);
+  const other = renderHook(() =>
+    useHiddenDms("community:bob", h.session, h.list),
+  );
+  expect(other.result.current.hiddenIds.has("dm")).toBe(false);
+
+  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(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, h.list),
+  );
+  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, 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, h.list),
+  );
+  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: 100 }],
+    expect.objectContaining({ priority: "background" }),
+  );
+});
+
+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 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();
+  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("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();
+  h.history(["before", "older"]);
+  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(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(() =>
+    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);
+  act(() => h.deliver("dm"));
+  expect(view.result.current.hiddenIds.has("dm")).toBe(false);
+});
+
+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
new file mode 100644
index 000000000..d2b8f24c3
--- /dev/null
+++ b/src/bundled/channels/useHiddenDms.ts
@@ -0,0 +1,232 @@
+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 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[];
+};
+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 [];
+  return saved.flatMap((entry) => {
+    if (!entry || typeof entry !== "object" || typeof entry.id !== "string")
+      return [];
+    const baseline = entry.baseline;
+    const knownIds = entry.knownIds;
+    return [
+      {
+        id: entry.id,
+        hideGeneration: Symbol(),
+        ...(baseline === null ||
+        (baseline &&
+          typeof baseline === "object" &&
+          typeof baseline.id === "string" &&
+          typeof baseline.createdAt === "number" &&
+          Number.isFinite(baseline.createdAt))
+          ? { baseline }
+          : {}),
+        ...(Array.isArray(knownIds) &&
+        knownIds.every((id): id is string => typeof id === "string")
+          ? { knownIds }
+          : {}),
+      },
+    ];
+  });
+}
+
+/** Local, viewer-scoped sidebar intent; verified message evidence restores a row. */
+export function useHiddenDms(
+  scope: string,
+  session: RelaySession,
+  list: ChannelList,
+) {
+  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[]) => {
+      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,
+          hideGeneration: Symbol(),
+          ...(latest ? { baseline: latest } : {}),
+        },
+      ]);
+    },
+    [session, update],
+  );
+
+  useEffect(() => {
+    if (!hidden.length) return;
+    const check = () => {
+      const next = current.current.flatMap((entry) => {
+        const latest = session.unread.snapshot({
+          kind: "channel",
+          channelId: entry.id,
+        }).latestMessage;
+        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 [];
+        // 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 ||
+        next.some((entry, index) => entry !== current.current[index])
+      )
+        update(next);
+    };
+    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 () => {
+        const hiddenNow = current.current.find((entry) => entry.id === id);
+        if (hiddenNow?.hideGeneration === hiddenAtSend.hideGeneration)
+          show([id]);
+      };
+    });
+    check();
+    return () => {
+      for (const stop of stops) stop();
+      stopIncoming();
+      stopOutgoing?.();
+    };
+  }, [hidden, session, show, update]);
+
+  useEffect(() => {
+    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 () => {
+      for (const id of hiddenKey.split("\u0000")) {
+        if (controller.signal.aborted) return;
+        const entry = current.current.find((item) => item.id === id);
+        if (!entry) 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: entry.knownIds ? 50 : 100,
+                },
+              ],
+              {
+                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));
+              if (changed) {
+                show([id]);
+                break;
+              }
+              if (entry.baseline === undefined || !entry.knownIds)
+                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);
+          }
+        }
+      }
+    })();
+    return () => controller.abort();
+  }, [hiddenKey, session, dmRosterKey, show, update]);
+
+  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/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 })
diff --git a/tests/browser/sidebar-unread.spec.mjs b/tests/browser/sidebar-unread.spec.mjs
index b50131f42..0c8e0cf8a 100644
--- a/tests/browser/sidebar-unread.spec.mjs
+++ b/tests/browser/sidebar-unread.spec.mjs
@@ -48,6 +48,72 @@ 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 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);
+
+  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();
+});
+
 test("channel establishment preserves an in-flight unread batch and its sidebar badges", async ({
   page,
   app,
@@ -230,9 +296,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");