diff --git a/docs/plugin-architecture.md b/docs/plugin-architecture.md
index 98778ff166..0590e870bc 100644
--- a/docs/plugin-architecture.md
+++ b/docs/plugin-architecture.md
@@ -84,7 +84,9 @@ retain a hidden Channels page or message reader. Sidebar and page render errors
 have separate boundaries. A page sidebar is isolated by the same owned-contribution
 boundary, so a failure falls back to a concise alert without taking down the page,
 Settings, or shell. The host owns the slot, collapse state, labels, and narrow drawer;
-the page owns its sidebar content and local interaction state.
+the page owns its sidebar content and local interaction state. Sidebar presentation
+helpers remain importable from `bundled/channels`; the conversation sidebar also
+exposes a versioned section contribution for plugins.
 
 Channels is the page-authoring example, not a thin registration wrapper over a
 host-owned product page. Keep page-specific components, styles, interactions and tests
@@ -203,6 +205,56 @@ remaining acceptance work and historical evidence.
 
 ## Starting contracts
 
+### Conversation sidebar sections
+
+A plugin may register a versioned `sidebarSections` contribution. Read it with
+`ctx.reflect.get("sidebarSections")` instead of adding it to required `inject`;
+the lookup returns `undefined` when an older host has not provided the capability. The host
+renders its rows inside the existing Team sidebar using the same collapsible,
+reorderable, resizable section frame as built-in
+sections. It owns presentation and persists contributed section expansion and
+relative order; a plugin supplies row data and actions, not another sidebar.
+
+Each registration is owned by the plugin's Cordis scope and is removed on
+disable, replacement, or teardown. Rows use an external-store snapshot and
+subscription: return a stable immutable array until the data changes, then notify
+listeners. `select` is a pure row-to-`OpenTarget` function used for both active
+selection and opening the row. Optional
+header actions are compact buttons; each has a stable id, accessible label,
+icon, and callback. A render failure replaces only that section with its
+unavailable state, and rejected row/header actions stay local to that section.
+
+```tsx
+import { createElement } from "react";
+
+const rows = [{
+  id: "today",
+  label: "Today",
+  count: 2,
+}];
+const listeners = new Set<() => void>();
+ctx.reflect.get("sidebarSections")?.register({
+  version: 1,
+  id: "work",
+  title: "Work",
+  icon: "W",
+  rows: {
+    snapshot: () => rows,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+  },
+  select: () => ({ version: 1, kind: "home" }),
+  actions: [{
+    id: "new",
+    label: "New item",
+    icon: createElement("span", { "aria-hidden": true }, "+"),
+    onSelect: createItem,
+  }],
+});
+```
+
 A plugin exports `inject` and `apply(ctx)`. Pages register with
 `ctx.pages.register({ id, title, layout?, companion?, primary?, placement?, icon?, component, sidebar? })`. Panels register with
 `ctx.panels.register({ id, title, matches, order?, launcher?, toolbar?, component })`. An optional `toolbar` supplies live controls beside shell search in place of the static launcher. Its lifetime stays with its plugin, and shell render failures are isolated. Huddles is the first caller. IDs are local to the
diff --git a/src/app/App.tsx b/src/app/App.tsx
index f96b73a842..778018a4e8 100644
--- a/src/app/App.tsx
+++ b/src/app/App.tsx
@@ -369,6 +369,7 @@ function ConnectedApp({ services }: { services: AppServices }) {
                   navigator={services.navigation}
                   agents={services.agents}
                   chatIcons={services.conversation.chatIcons}
+                  sidebarSections={services.sidebarSections}
                   target={workspace.target}
                 >
                   {pageNavigation}
diff --git a/src/app/services.ts b/src/app/services.ts
index bf170f004f..1505998a42 100644
--- a/src/app/services.ts
+++ b/src/app/services.ts
@@ -35,6 +35,7 @@ import { PanelsService } from "../features/panels/service";
 import { Context } from "@deepseek-ai/cordis";
 import { BrowserService } from "../features/browser/service";
 import { PagesService } from "../features/pages/service";
+import { SidebarSectionsService } from "../features/channel-navigation/sidebar-sections-service";
 import { bundledPlugins } from "../bundled";
 import { createPluginManager } from "../plugins/manager";
 import { withTimeout } from "../plugins/timeout";
@@ -56,6 +57,7 @@ export function createServices() {
   const shortcuts = new ShortcutsService(ctx, undefined, shortcutBindings);
   const decisions = new DecisionsService(ctx);
   const pages = new PagesService(ctx);
+  const sidebarSections = new SidebarSectionsService(ctx);
   const panels = new PanelsService(ctx);
   const accountActions = new AccountActionsService(ctx);
   const conversation = new ConversationService(ctx);
@@ -140,6 +142,7 @@ export function createServices() {
     settingsCards,
     adminAccess,
     pages,
+    sidebarSections,
     panels,
     plugins,
     relay,
diff --git a/src/app/shell/PrimarySidebar.tsx b/src/app/shell/PrimarySidebar.tsx
index 332138204c..7e28b6cb7c 100644
--- a/src/app/shell/PrimarySidebar.tsx
+++ b/src/app/shell/PrimarySidebar.tsx
@@ -29,6 +29,7 @@ import { readView, writeView } from "../../shared/view-state";
 import type { ChannelList } from "../../features/relay/contracts";
 import type { ContributionReader } from "../../features/conversation/contracts";
 import type { ChatIcon } from "../../features/conversation/service";
+import type { SidebarSections } from "../../features/channel-navigation/sidebar-sections-service";
 
 const noSubscription = () => () => {};
 
@@ -44,6 +45,7 @@ type Props = {
   navigator: Navigation;
   agents?: Agents | undefined;
   chatIcons?: ContributionReader<ChatIcon> | undefined;
+  sidebarSections?: SidebarSections | undefined;
   target: OpenTarget;
   children: ReactNode;
 };
@@ -180,6 +182,7 @@ function ScopedSidebar({
           queries={connection.session}
           scope={scope}
           viewer={connection.viewer}
+          sidebarSections={props.sidebarSections}
           cached={!!connection.cached}
           layoutReady={filter === "team" || soloReady}
           connectionError={connection.error}
diff --git a/src/bundled/channels/Channels.module.css b/src/bundled/channels/Channels.module.css
index 60eec31fd1..243c03c2ce 100644
--- a/src/bundled/channels/Channels.module.css
+++ b/src/bundled/channels/Channels.module.css
@@ -97,6 +97,25 @@
   flex: 0 0 1.125rem;
   place-items: center;
 }
+.contributionNavigationItem {
+  width: 100%;
+  min-width: 0;
+  container-type: inline-size;
+}
+.contributionMetadata {
+  display: block;
+  min-width: 0;
+  overflow-wrap: anywhere;
+  text-align: end;
+  white-space: normal;
+}
+@container (max-width: 17rem) {
+  .contributionNavigationItem [class~="navigation-item-trailing"] {
+    max-width: 40%;
+    min-width: 0;
+    flex: 0 1 auto;
+  }
+}
 .channelListFrame {
   position: relative;
   /* Bring the scrollbar near the divider without clipping its native thumb. */
@@ -361,6 +380,13 @@
   overflow: hidden;
   white-space: nowrap;
 }
+.contributionFeedback {
+  margin: 0;
+  padding: var(--space-1) var(--space-2);
+  color: var(--text-danger);
+  font-size: var(--text-body-sm);
+  line-height: var(--text-body-sm--line-height);
+}
 .sectionLabel [data-sidebar-group-icon] {
   width: var(--space-5);
   margin-inline-end: var(--space-1);
diff --git a/src/bundled/channels/SidebarSection.tsx b/src/bundled/channels/SidebarSection.tsx
index b11393fb3e..19cfe4604d 100644
--- a/src/bundled/channels/SidebarSection.tsx
+++ b/src/bundled/channels/SidebarSection.tsx
@@ -57,6 +57,9 @@ export function SidebarSection({
   session,
   open,
   onToggle,
+  headerActions,
+  headerNotice,
+  hideMoreActions = false,
   createChannel,
   newMessage,
   sort,
@@ -76,11 +79,14 @@ export function SidebarSection({
   sectionKey: string;
   title: string;
   hideTitle?: boolean;
-  icon?: string | undefined;
+  icon?: ReactNode;
   session?: RelaySession | undefined;
   open: boolean;
   onToggle: (open: boolean) => void;
+  headerActions?: ReactNode;
+  headerNotice?: ReactNode;
   onRemove?: (() => unknown) | undefined;
+  hideMoreActions?: boolean;
   channelCount?: number | undefined;
   removalFocus?: (() => HTMLElement | null | undefined) | undefined;
   createChannel?:
@@ -196,9 +202,11 @@ export function SidebarSection({
             <span className={styles.sectionLabel}>
               {sectionKey === "starred" ? (
                 <SidebarStarIcon />
-              ) : icon && session ? (
+              ) : typeof icon === "string" && session ? (
                 <SidebarGroupIcon icon={icon} session={session} />
-              ) : null}
+              ) : (
+                icon
+              )}
               <FadingLabel className={styles.sectionTitle}>{title}</FadingLabel>
             </span>
             <span className={`${styles.sidebarIcon} ${styles.sectionChevron}`}>
@@ -213,6 +221,7 @@ export function SidebarSection({
               render={(props) => (
                 <IconButton
                   {...props}
+                  hidden={hideMoreActions}
                   size="compact"
                   aria-label={`More actions for ${title}`}
                   icon={<DotsThreeIcon strokeWidth={2.5} size={15} />}
@@ -410,6 +419,7 @@ export function SidebarSection({
               )}
             </MenuPopup>
           </MenuRoot>
+          {headerActions}
           {newMessage && (
             <IconButton
               size="compact"
@@ -490,6 +500,7 @@ export function SidebarSection({
           )}
         </div>
       </div>
+      {headerNotice}
       <div
         id={id}
         className={styles.sectionContent}
diff --git a/src/bundled/channels/sidebar-sections.test.ts b/src/bundled/channels/sidebar-sections.test.ts
index 614a33987d..24948fd2c2 100644
--- a/src/bundled/channels/sidebar-sections.test.ts
+++ b/src/bundled/channels/sidebar-sections.test.ts
@@ -1,11 +1,25 @@
 import { expect, it } from "vitest";
 import type { ChannelSummary } from "../../features/relay/contracts";
 import {
+  orderContributedSidebarSections,
   isChannelDropSectionKey,
   isChannelSectionKey,
   sidebarSections,
 } from "./sidebar-sections";
 
+it("keeps contributed order stable and lets saved preferences lead", () => {
+  const sections = [
+    { key: "plugin/a" },
+    { key: "plugin/b" },
+    { key: "plugin/c" },
+  ];
+  expect(
+    orderContributedSidebarSections(sections, ["plugin/c", "plugin/a"]).map(
+      ({ key }) => key,
+    ),
+  ).toEqual(["plugin/c", "plugin/a", "plugin/b"]);
+});
+
 const row = (
   id: string,
   extra: Partial<ChannelSummary> = {},
diff --git a/src/bundled/channels/sidebar-sections.ts b/src/bundled/channels/sidebar-sections.ts
index 5bbaf2b726..9e184c7745 100644
--- a/src/bundled/channels/sidebar-sections.ts
+++ b/src/bundled/channels/sidebar-sections.ts
@@ -9,6 +9,26 @@ export function isChannelDropSectionKey(key: string) {
   return key === "starred" || isChannelSectionKey(key);
 }
 
+export function contributedSidebarSectionKey(key: string) {
+  return `plugin:${key}`;
+}
+
+export function orderContributedSidebarSections<T extends { key: string }>(
+  sections: readonly T[],
+  order: readonly string[],
+) {
+  const position = new Map(order.map((key, index) => [key, index]));
+  return sections
+    .map((section, index) => ({ section, index }))
+    .sort(
+      (a, b) =>
+        (position.get(a.section.key) ?? Number.MAX_SAFE_INTEGER) -
+          (position.get(b.section.key) ?? Number.MAX_SAFE_INTEGER) ||
+        a.index - b.index,
+    )
+    .map(({ section }) => section);
+}
+
 /** Preferences only arrange the supplied authorized roster; they never add channels. */
 export function sidebarSections<T extends ChannelSummary>(
   channels: readonly T[],
diff --git a/src/bundled/channels/useSidebarView.ts b/src/bundled/channels/useSidebarView.ts
index 71fa28ad3e..6a27012fb0 100644
--- a/src/bundled/channels/useSidebarView.ts
+++ b/src/bundled/channels/useSidebarView.ts
@@ -3,6 +3,7 @@ import { readView, subscribeView, writeView } from "../../shared/view-state";
 
 type SidebarView = {
   collapsed: string[];
+  contributionOrder: string[];
   scrollTop: number;
   /** The destination whose sidebar entry the saved position shows. */
   location?: string | undefined;
@@ -16,6 +17,11 @@ function restore(scope: string): SidebarView {
     collapsed: Array.isArray(saved.collapsed)
       ? saved.collapsed.filter((key): key is string => typeof key === "string")
       : [],
+    contributionOrder: Array.isArray(saved.contributionOrder)
+      ? saved.contributionOrder.filter(
+          (key): key is string => typeof key === "string",
+        )
+      : [],
     scrollTop:
       typeof saved.scrollTop === "number" &&
       Number.isFinite(saved.scrollTop) &&
@@ -97,12 +103,19 @@ export function useSidebarView(
   useLayoutEffect(
     () =>
       subscribeView(scope, () => {
-        const collapsed = restore(scope).collapsed;
+        const saved = restore(scope);
         if (
-          JSON.stringify(collapsed) === JSON.stringify(intent.current.collapsed)
+          JSON.stringify(saved.collapsed) ===
+            JSON.stringify(intent.current.collapsed) &&
+          JSON.stringify(saved.contributionOrder) ===
+            JSON.stringify(intent.current.contributionOrder)
         )
           return;
-        intent.current = { ...intent.current, collapsed };
+        intent.current = {
+          ...intent.current,
+          collapsed: saved.collapsed,
+          contributionOrder: saved.contributionOrder,
+        };
         setView(intent.current);
       }),
     [scope],
@@ -155,6 +168,7 @@ export function useSidebarView(
   // The entry can render after navigation (roster startup, a new DM), so
   // retry after each commit until it exists. Runs after the restore above.
   const attempt = useRef(() => {});
+  const retryReveal = useCallback(() => attempt.current(), []);
   useLayoutEffect(() => {
     attempt.current = () => {
       if (!ready || !reveal.current || !list.current) return;
@@ -220,9 +234,18 @@ export function useSidebarView(
     },
     [update],
   );
+  const setContributionOrder = useCallback(
+    (contributionOrder: readonly string[]) => {
+      update({ ...intent.current, contributionOrder: [...contributionOrder] });
+    },
+    [update],
+  );
   return {
     list,
     collapsed: view.collapsed,
+    contributionOrder: view.contributionOrder,
+    setContributionOrder,
     toggle,
+    retryReveal,
   };
 }
diff --git a/src/features/channel-navigation/ChannelInventory.test.tsx b/src/features/channel-navigation/ChannelInventory.test.tsx
index 3d092e6e0b..8994c0710f 100644
--- a/src/features/channel-navigation/ChannelInventory.test.tsx
+++ b/src/features/channel-navigation/ChannelInventory.test.tsx
@@ -24,6 +24,10 @@ import type {
 import type { RelayData, RelaySnapshot } from "../relay/service";
 import type { ChannelList } from "../relay/contracts";
 import type { Navigation } from "../navigation/controller";
+import type {
+  RegisteredSidebarSection,
+  SidebarSections,
+} from "./sidebar-sections-service";
 import { createRef, type ReactNode } from "react";
 import userEvent from "@testing-library/user-event";
 import { ChannelHeaderMenu } from "../../bundled/channels/ChannelHeaderMenu";
@@ -101,6 +105,7 @@ function fixture(
     { id: "beta", name: "beta", channelType: "stream" },
     { id: "gamma", name: "gamma", channelType: "stream" },
   ],
+  sidebarSections?: SidebarSections,
 ) {
   const owner = createRelaySession(null);
   owners.push(owner);
@@ -202,6 +207,7 @@ function fixture(
                 communityOrigin: "https://relay.test",
               },
             }}
+            sidebarSections={sidebarSections}
           >
             {pages}
           </PrimarySidebar>
@@ -410,6 +416,76 @@ it("ignores local and legacy filter state", async () => {
   expect(screen.getByRole("button", { name: "gamma" })).toBeVisible();
 });
 
+it("preserves disabled contribution positions when active sections reorder", async () => {
+  const makeSection = (id: string): RegisteredSidebarSection => {
+    const rows = [{ id: `${id}-row`, label: `${id.toUpperCase()} item` }];
+    return {
+      version: 1,
+      id,
+      title: id.toUpperCase(),
+      icon: "★",
+      rows: { snapshot: () => rows, subscribe: () => () => {} },
+      select: () => ({ version: 1, kind: "home" }),
+      key: `example.plugin/${id}`,
+      pluginId: "example.plugin",
+      revision: "one",
+    };
+  };
+  const [a, b, c] = ["a", "b", "c"].map(makeSection);
+  assert(a && b && c);
+  let active: readonly RegisteredSidebarSection[] = [a, c];
+  const listeners = new Set<() => void>();
+  const registry: SidebarSections = {
+    version: 1,
+    snapshot: () => active,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    register: () => {},
+  };
+  const h = fixture(undefined, "ready", [], registry);
+  const scope = h.snapshot.scope;
+  assert.exists(scope);
+  writeView(scope, "channel-sidebar", {
+    collapsed: [],
+    contributionOrder: [a.key, b.key, c.key],
+    scrollTop: 0,
+  });
+  const visibleOrder = () =>
+    [
+      ...document.querySelectorAll<HTMLElement>(
+        '[data-sidebar-section^="plugin:example.plugin/"]',
+      ),
+    ].map((section) => section.dataset.sidebarSection);
+  const user = userEvent.setup();
+
+  render(h.view("alpha"));
+  await waitFor(() =>
+    expect(visibleOrder()).toEqual([
+      "plugin:example.plugin/a",
+      "plugin:example.plugin/c",
+    ]),
+  );
+  await user.click(screen.getByRole("button", { name: "More actions for C" }));
+  await user.click(await screen.findByRole("menuitem", { name: "Move up" }));
+
+  expect(readView(scope, "channel-sidebar", {})).toMatchObject({
+    contributionOrder: [c.key, b.key, a.key],
+  });
+  act(() => {
+    active = [a, b, c];
+    for (const listener of listeners) listener();
+  });
+  await waitFor(() =>
+    expect(visibleOrder()).toEqual([
+      "plugin:example.plugin/c",
+      "plugin:example.plugin/b",
+      "plugin:example.plugin/a",
+    ]),
+  );
+});
+
 it("does not rebuild unchanged rows on channel switches", async () => {
   const h = fixture();
   const mounted = render(h.view("alpha"));
diff --git a/src/features/channel-navigation/ChannelInventory.tsx b/src/features/channel-navigation/ChannelInventory.tsx
index 6d98f3ede3..b5156bd00b 100644
--- a/src/features/channel-navigation/ChannelInventory.tsx
+++ b/src/features/channel-navigation/ChannelInventory.tsx
@@ -20,6 +20,10 @@ import type { RelaySession } from "../relay/session";
 import { useChannelList } from "../relay/react";
 import type { Navigation } from "../navigation/controller";
 import type { OpenTarget } from "../navigation/targets";
+import type {
+  RegisteredSidebarSection,
+  SidebarSections,
+} from "./sidebar-sections-service";
 import type { SidebarFrame } from "./SidebarFrame";
 import { Button } from "../../shared/design-system/ui/Button";
 import {
@@ -67,9 +71,16 @@ import { useSidebarView } from "../../bundled/channels/useSidebarView";
 import { useSidebarFilters } from "../../bundled/channels/useSidebarFilters";
 import {
   sidebarSections,
+  contributedSidebarSectionKey,
   isChannelSectionKey,
   isChannelDropSectionKey,
+  orderContributedSidebarSections,
 } from "../../bundled/channels/sidebar-sections";
+import { SidebarContributionSection } from "./SidebarContributionSection";
+import {
+  ContributionBoundary,
+  contributionKey,
+} from "../conversation/ContributionBoundary";
 import {
   CreateChannelDialog,
   type CreateChannelInput,
@@ -94,6 +105,16 @@ type Inventory = {
   dialogs: ReactNode;
 };
 
+const noSubscription = () => () => {};
+const emptyContributions: readonly RegisteredSidebarSection[] = [];
+const noSidebarSections = () => emptyContributions;
+const emptySidebarSections: SidebarSections = {
+  version: 1,
+  snapshot: noSidebarSections,
+  subscribe: noSubscription,
+  register: () => {},
+};
+
 /** Channel data, actions and notices; the primary sidebar owns their framing. */
 export function ChannelInventory({
   relay,
@@ -106,6 +127,7 @@ export function ChannelInventory({
   connectionError,
   scope,
   viewer,
+  sidebarSections: contributedSections,
   render,
 }: {
   relay: RelayData;
@@ -119,8 +141,14 @@ export function ChannelInventory({
   connectionError?: string | undefined;
   scope: string;
   viewer?: string | undefined;
+  sidebarSections?: SidebarSections | undefined;
   render(inventory: Inventory): ReactNode;
 }) {
+  const contributions = useSyncExternalStore(
+    contributedSections?.subscribe ?? noSubscription,
+    contributedSections?.snapshot ?? noSidebarSections,
+    contributedSections?.snapshot ?? noSidebarSections,
+  );
   const list = useChannelList(queries.channels);
   const recoveryShown = useRecoveryShown(queries.recovery);
   const preferences = useSidebarPreferences(queries.sidebarPreferences);
@@ -533,6 +561,35 @@ export function ChannelInventory({
   // Group drags land on the placement drop targets, so they need both writers.
   const orderWritable = placementWritable && preferences.sectionOrderWritable;
   const groupIds = preferences.data?.sections.map(({ id }) => id) ?? [];
+  const orderedContributions = orderContributedSidebarSections(
+    contributions,
+    sidebar.contributionOrder,
+  );
+  const reorderContributions = (sectionKey: string, overKey: string) => {
+    const key = sectionKey.replace(/^plugin:/, "");
+    const over = overKey.replace(/^plugin:/, "");
+    const ids = orderedContributions.map(({ key }) => key);
+    const from = ids.indexOf(key);
+    const to = ids.indexOf(over);
+    if (from < 0 || to < 0) return;
+    ids.splice(from, 1);
+    ids.splice(to, 0, key);
+    const activeKeys = new Set(ids);
+    const seenSavedKeys = new Set<string>();
+    const order: string[] = [];
+    let nextActive = 0;
+    for (const savedKey of sidebar.contributionOrder) {
+      if (!activeKeys.has(savedKey)) {
+        order.push(savedKey);
+        continue;
+      }
+      if (seenSavedKeys.has(savedKey)) continue;
+      seenSavedKeys.add(savedKey);
+      order.push(ids[nextActive++] ?? savedKey);
+    }
+    order.push(...ids.slice(nextActive));
+    sidebar.setContributionOrder(order);
+  };
   const moveGroup = (sectionId: string, to: number) => {
     const ids = groupIds.filter((id) => id !== sectionId);
     ids.splice(to, 0, sectionId);
@@ -1057,22 +1114,38 @@ export function ChannelInventory({
                 )
           }
           onReorder={(sectionKey, overKey) =>
-            moveGroup(
-              sectionKey.slice("group:".length),
-              groupIds.indexOf(overKey.slice("group:".length)),
-            )
+            sectionKey.startsWith("plugin:")
+              ? reorderContributions(sectionKey, overKey)
+              : moveGroup(
+                  sectionKey.slice("group:".length),
+                  groupIds.indexOf(overKey.slice("group:".length)),
+                )
           }
           overlay={(id, group) => {
             if (group) {
               const section = sections.find(({ key }) => key === id);
-              return section ? (
+              const contribution = section
+                ? undefined
+                : orderedContributions.find(
+                    ({ key }) => contributedSidebarSectionKey(key) === id,
+                  );
+              const title = section?.title ?? contribution?.title;
+              if (!title) return null;
+              return (
                 <div className={styles.channelDragOverlay}>
-                  {section.icon && (
+                  {section?.icon ? (
                     <SidebarGroupIcon icon={section.icon} session={queries} />
-                  )}
-                  <span>{section.title}</span>
+                  ) : contribution?.icon ? (
+                    <ContributionBoundary
+                      key={contributionKey(contribution)}
+                      fallback={null}
+                    >
+                      {contribution.icon}
+                    </ContributionBoundary>
+                  ) : null}
+                  <span>{title}</span>
                 </div>
-              ) : null;
+              );
             }
             const channel = sidebarChannels.find(
               (channel) => channel.id === id,
@@ -1273,6 +1346,50 @@ export function ChannelInventory({
               })}
             </DroppableSidebarSection>
           ))}
+          {orderedContributions.map((entry, index) => {
+            const sectionKey = contributedSidebarSectionKey(entry.key);
+            const previousKey = orderedContributions[index - 1]?.key;
+            const nextKey = orderedContributions[index + 1]?.key;
+            const reorderable = contributions.length > 1;
+            return (
+              <SidebarContributionSection
+                key={entry.key}
+                entry={entry}
+                registry={contributedSections ?? emptySidebarSections}
+                navigator={navigator}
+                target={target}
+                open={!sidebar.collapsed.includes(sectionKey)}
+                onToggle={(open) => sidebar.toggle(sectionKey, open)}
+                groupIndex={index}
+                reorderable={reorderable}
+                onRowsCommitted={sidebar.retryReveal}
+                move={
+                  reorderable
+                    ? {
+                        ...(previousKey
+                          ? {
+                              up: () =>
+                                reorderContributions(
+                                  sectionKey,
+                                  contributedSidebarSectionKey(previousKey),
+                                ),
+                            }
+                          : {}),
+                        ...(nextKey
+                          ? {
+                              down: () =>
+                                reorderContributions(
+                                  sectionKey,
+                                  contributedSidebarSectionKey(nextKey),
+                                ),
+                            }
+                          : {}),
+                      }
+                    : undefined
+                }
+              />
+            );
+          })}
         </ChannelSidebarDnd>
         {!startup.ready && (
           <p className={styles.empty} role="status">
diff --git a/src/features/channel-navigation/ChannelSidebarDnd.tsx b/src/features/channel-navigation/ChannelSidebarDnd.tsx
index 0c4c551550..639381f5a4 100644
--- a/src/features/channel-navigation/ChannelSidebarDnd.tsx
+++ b/src/features/channel-navigation/ChannelSidebarDnd.tsx
@@ -26,9 +26,20 @@ const Writable = createContext(false);
 
 // Group gaps target the neighbour whose insertion edge lies in that same gap.
 const sidebarCollisions: CollisionDetection = (args) => {
-  if (!args.active.data.current?.group) return pointerWithin(args);
+  const domain = args.active.data.current?.groupDomain ?? "channels";
+  if (!args.active.data.current?.group)
+    return pointerWithin({
+      ...args,
+      droppableContainers: args.droppableContainers.filter(
+        ({ data }) => (data.current?.groupDomain ?? "channels") === domain,
+      ),
+    });
   const groups = args.droppableContainers
-    .filter(({ id }) => String(id).startsWith("group:"))
+    .filter(
+      ({ data }) =>
+        data.current?.group &&
+        (data.current?.groupDomain ?? "channels") === domain,
+    )
     .sort((a, b) => a.data.current?.groupIndex - b.data.current?.groupIndex);
   const hits = pointerWithin({ ...args, droppableContainers: groups });
   if (hits.length) return hits;
@@ -133,7 +144,7 @@ export function DraggableChannel({
 }) {
   const { setNodeRef, listeners, isDragging } = useDraggable({
     id: channelId,
-    data: { sectionKey },
+    data: { sectionKey, groupDomain: "channels" },
     disabled: !useContext(Writable),
   });
   return (
@@ -152,15 +163,17 @@ export function DroppableSidebarSection({
   disabled,
   reorderable,
   groupIndex,
+  groupDomain = "channels",
   ...section
 }: ComponentProps<typeof SidebarSection> & {
   disabled: boolean;
   reorderable: boolean;
   groupIndex: number;
+  groupDomain?: string;
 }) {
   const { setNodeRef, isOver, active } = useDroppable({
     id: section.sectionKey,
-    data: { groupIndex },
+    data: { group: reorderable, groupIndex, groupDomain },
     disabled,
     // dnd-kit queues a re-measure of only the droppable that resized and clears
     // that queue after each render, losing ids queued in between: a section
@@ -171,7 +184,7 @@ export function DroppableSidebarSection({
   });
   const drag = useDraggable({
     id: section.sectionKey,
-    data: { group: true, groupIndex },
+    data: { group: true, groupIndex, groupDomain },
     disabled: !reorderable,
   });
   const suppressClick = useRef(false);
diff --git a/src/features/channel-navigation/SidebarContributionSection.test.tsx b/src/features/channel-navigation/SidebarContributionSection.test.tsx
new file mode 100644
index 0000000000..c4c7888d7e
--- /dev/null
+++ b/src/features/channel-navigation/SidebarContributionSection.test.tsx
@@ -0,0 +1,425 @@
+// @vitest-environment jsdom
+import { act, cleanup, render, screen } from "@testing-library/react";
+import "@testing-library/jest-dom/vitest";
+import userEvent from "@testing-library/user-event";
+import { afterEach, expect, it, vi } from "vitest";
+import type { Navigation } from "../navigation/controller";
+import type { OpenTarget } from "../navigation/targets";
+import type {
+  RegisteredSidebarSection,
+  SidebarSectionRow,
+  SidebarSections,
+} from "./sidebar-sections-service";
+import { SidebarContributionSection } from "./SidebarContributionSection";
+import { ChannelSidebarDnd } from "./ChannelSidebarDnd";
+
+const target: OpenTarget = { version: 1, kind: "home" };
+const row = {
+  id: "item",
+  label: "Useful item",
+  badge: "New",
+  count: 2,
+  status: "Active",
+};
+
+function ThrowingIcon(): never {
+  throw new Error("fixture icon failed");
+}
+
+function makeEntry(
+  id: string,
+  rows: RegisteredSidebarSection["rows"],
+): RegisteredSidebarSection {
+  return {
+    version: 1,
+    id,
+    title: id === "good" ? "Good section" : "Broken section",
+    icon: "★",
+    rows,
+    select: () => target,
+    key: `fixture/${id}`,
+    pluginId: "fixture",
+    revision: "one",
+  };
+}
+
+afterEach(cleanup);
+
+it("isolates a contribution render failure and keeps sibling section actions usable", async () => {
+  const consoleError = vi.spyOn(console, "error").mockImplementation(() => {});
+  const broken = {
+    ...makeEntry("broken", {
+      snapshot: () => [row],
+      subscribe: () => () => {},
+    }),
+    icon: <ThrowingIcon />,
+  };
+  const action = vi.fn().mockRejectedValue(new Error("fixture action failed"));
+  let goodRows: readonly SidebarSectionRow[] = [row];
+  const rowListeners = new Set<() => void>();
+  const good: RegisteredSidebarSection = {
+    ...makeEntry("good", {
+      snapshot: () => goodRows,
+      subscribe(listener) {
+        rowListeners.add(listener);
+        return () => rowListeners.delete(listener);
+      },
+    }),
+    actions: [
+      {
+        id: "new",
+        label: "Create item",
+        icon: <span aria-hidden="true">+</span>,
+        onSelect: action,
+      },
+    ],
+  };
+  const registry: SidebarSections = {
+    version: 1,
+    snapshot: () => [broken, good],
+    subscribe: () => () => {},
+    register: () => {},
+  };
+  const open = vi.fn().mockResolvedValue({ status: "opened" });
+  const navigator = { open } as unknown as Navigation;
+
+  render(
+    <ChannelSidebarDnd
+      writable={false}
+      onMove={() => {}}
+      onReorder={() => {}}
+      overlay={() => null}
+    >
+      {[broken, good].map((entry, index) => (
+        <SidebarContributionSection
+          key={entry.key}
+          entry={entry}
+          registry={registry}
+          navigator={navigator}
+          target={target}
+          open
+          onToggle={() => {}}
+          groupIndex={index}
+          reorderable={false}
+          move={{}}
+        />
+      ))}
+    </ChannelSidebarDnd>,
+  );
+
+  expect(screen.getByText(/Broken section is unavailable/)).toHaveTextContent(
+    "Other sidebar sections remain available.",
+  );
+  const rowButton = screen.getByRole("button", { name: /Useful item/ });
+  const user = userEvent.setup();
+  await user.click(rowButton);
+  expect(open).toHaveBeenCalledWith(target);
+  expect(screen.getByText("New · 2 · Active")).toBeTruthy();
+  await user.click(screen.getByRole("button", { name: "Create item" }));
+  expect(action).toHaveBeenCalledOnce();
+  expect(
+    await screen.findByText("This sidebar action couldn’t finish."),
+  ).toBeInTheDocument();
+  act(() => {
+    goodRows = [row, { id: "later", label: "Later item" }];
+    for (const listener of rowListeners) listener();
+  });
+  expect(screen.getByRole("button", { name: "Later item" })).toBeTruthy();
+  expect(consoleError).toHaveBeenCalled();
+});
+
+it("keeps failed header-action feedback visible while the section is collapsed", async () => {
+  const action = vi.fn().mockRejectedValue(new Error("fixture action failed"));
+  const rows: readonly SidebarSectionRow[] = [];
+  const entry: RegisteredSidebarSection = {
+    ...makeEntry("good", {
+      snapshot: () => rows,
+      subscribe: () => () => {},
+    }),
+    actions: [
+      {
+        id: "new",
+        label: "Create item",
+        icon: <span aria-hidden="true">+</span>,
+        onSelect: action,
+      },
+    ],
+  };
+  const registry: SidebarSections = {
+    version: 1,
+    snapshot: () => [entry],
+    subscribe: () => () => {},
+    register: () => {},
+  };
+
+  render(
+    <ChannelSidebarDnd
+      writable={false}
+      onMove={() => {}}
+      onReorder={() => {}}
+      overlay={() => null}
+    >
+      <SidebarContributionSection
+        entry={entry}
+        registry={registry}
+        navigator={{ open: vi.fn() } as unknown as Navigation}
+        target={target}
+        open={false}
+        onToggle={() => {}}
+        groupIndex={0}
+        reorderable={false}
+        move={{}}
+      />
+    </ChannelSidebarDnd>,
+  );
+
+  const sectionTitle = screen.getByText("Good section");
+  expect(sectionTitle.closest("details")).not.toHaveAttribute("open");
+  await userEvent
+    .setup()
+    .click(screen.getByRole("button", { name: "Create item" }));
+
+  expect(await screen.findByRole("alert")).toHaveTextContent(
+    "This sidebar action couldn’t finish.",
+  );
+  expect(sectionTitle.closest("details")).not.toHaveAttribute("open");
+});
+
+it("selects an unscoped page row in its current community only", () => {
+  const scope = {
+    viewer: "a".repeat(64),
+    communityOrigin: "https://relay.example",
+  };
+  const current: OpenTarget = {
+    version: 1,
+    kind: "page",
+    pluginId: "fixture.pages",
+    pageId: "board",
+    scope,
+  };
+  const rows: readonly SidebarSectionRow[] = [
+    { id: "current", label: "Current community page" },
+    { id: "personal", label: "Personal page" },
+    { id: "other", label: "Other community page" },
+  ];
+  const destinations: Record<string, OpenTarget> = {
+    current: {
+      version: 1,
+      kind: "page",
+      pluginId: current.pluginId,
+      pageId: current.pageId,
+    },
+    personal: {
+      version: 1,
+      kind: "page",
+      pluginId: current.pluginId,
+      pageId: current.pageId,
+      scope: null,
+    },
+    other: {
+      version: 1,
+      kind: "page",
+      pluginId: current.pluginId,
+      pageId: current.pageId,
+      scope: { ...scope, communityOrigin: "https://other.example" },
+    },
+  };
+  const entry: RegisteredSidebarSection = {
+    ...makeEntry("good", {
+      snapshot: () => rows,
+      subscribe: () => () => {},
+    }),
+    select: (item) => {
+      const destination = destinations[item.id];
+      if (!destination) throw new Error("Missing fixture destination");
+      return destination;
+    },
+  };
+  const registry: SidebarSections = {
+    version: 1,
+    snapshot: () => [entry],
+    subscribe: () => () => {},
+    register: () => {},
+  };
+
+  render(
+    <ChannelSidebarDnd
+      writable={false}
+      onMove={() => {}}
+      onReorder={() => {}}
+      overlay={() => null}
+    >
+      <SidebarContributionSection
+        entry={entry}
+        registry={registry}
+        navigator={{ open: vi.fn() } as unknown as Navigation}
+        target={current}
+        open
+        onToggle={() => {}}
+        groupIndex={0}
+        reorderable={false}
+        move={{}}
+      />
+    </ChannelSidebarDnd>,
+  );
+
+  expect(
+    screen.getByRole("button", { name: "Current community page" }),
+  ).toHaveAttribute("aria-current", "page");
+  expect(
+    screen.getByRole("button", { name: "Personal page" }),
+  ).not.toHaveAttribute("aria-current");
+  expect(
+    screen.getByRole("button", { name: "Other community page" }),
+  ).not.toHaveAttribute("aria-current");
+});
+
+it("keeps conversation-level rows selected through in-conversation navigation", () => {
+  const scope = {
+    viewer: "a".repeat(64),
+    communityOrigin: "https://relay.example",
+  };
+  const conversation: OpenTarget = {
+    version: 1,
+    kind: "conversation",
+    scope,
+    channelId: "alpha",
+  };
+  const message: OpenTarget = {
+    ...conversation,
+    messageId: "b".repeat(64),
+  };
+  const rows: readonly SidebarSectionRow[] = [
+    { id: "conversation", label: "Conversation" },
+    { id: "message", label: "Exact message" },
+    { id: "other-channel", label: "Other conversation" },
+    { id: "other-community", label: "Other community" },
+  ];
+  const destinations: Record<string, OpenTarget> = {
+    conversation,
+    message,
+    "other-channel": { ...conversation, channelId: "beta" },
+    "other-community": {
+      ...conversation,
+      scope: { ...scope, communityOrigin: "https://other.example" },
+    },
+  };
+  const entry: RegisteredSidebarSection = {
+    ...makeEntry("good", { snapshot: () => rows, subscribe: () => () => {} }),
+    select: (item) => {
+      const destination = destinations[item.id];
+      if (!destination) throw new Error("Missing fixture destination");
+      return destination;
+    },
+  };
+  const registry: SidebarSections = {
+    version: 1,
+    snapshot: () => [entry],
+    subscribe: () => () => {},
+    register: () => {},
+  };
+  const renderSection = (target: OpenTarget) => (
+    <ChannelSidebarDnd
+      writable={false}
+      onMove={() => {}}
+      onReorder={() => {}}
+      overlay={() => null}
+    >
+      <SidebarContributionSection
+        entry={entry}
+        registry={registry}
+        navigator={{ open: vi.fn() } as unknown as Navigation}
+        target={target}
+        open
+        onToggle={() => {}}
+        groupIndex={0}
+        reorderable={false}
+        move={{}}
+      />
+    </ChannelSidebarDnd>
+  );
+
+  const { rerender } = render(renderSection(message));
+  const conversationRow = () =>
+    screen.getByRole("button", { name: "Conversation" });
+  const exactMessageRow = () =>
+    screen.getByRole("button", { name: "Exact message" });
+
+  expect(conversationRow()).toHaveAttribute("aria-current", "page");
+  expect(exactMessageRow()).toHaveAttribute("aria-current", "page");
+
+  rerender(renderSection({ ...message, panel: "members" }));
+  expect(conversationRow()).toHaveAttribute("aria-current", "page");
+  expect(exactMessageRow()).not.toHaveAttribute("aria-current");
+
+  rerender(renderSection({ ...conversation, messageId: "c".repeat(64) }));
+  expect(conversationRow()).toHaveAttribute("aria-current", "page");
+  expect(exactMessageRow()).not.toHaveAttribute("aria-current");
+
+  rerender(
+    renderSection({
+      ...conversation,
+      scope: { ...scope, communityOrigin: "https://other.example" },
+    }),
+  );
+  expect(conversationRow()).not.toHaveAttribute("aria-current");
+  expect(exactMessageRow()).not.toHaveAttribute("aria-current");
+  expect(
+    screen.getByRole("button", { name: "Other conversation" }),
+  ).not.toHaveAttribute("aria-current");
+  expect(
+    screen.getByRole("button", { name: "Other community" }),
+  ).toHaveAttribute("aria-current", "page");
+});
+
+it("preserves the receiver for an external row store", () => {
+  const store: RegisteredSidebarSection["rows"] & {
+    rows: readonly SidebarSectionRow[];
+    listeners: Set<() => void>;
+  } = {
+    rows: [row],
+    listeners: new Set(),
+    snapshot() {
+      return this.rows;
+    },
+    subscribe(listener) {
+      this.listeners.add(listener);
+      return () => this.listeners.delete(listener);
+    },
+  };
+  const entry = makeEntry("good", store);
+  const registry: SidebarSections = {
+    version: 1,
+    snapshot: () => [entry],
+    subscribe: () => () => {},
+    register: () => {},
+  };
+
+  render(
+    <ChannelSidebarDnd
+      writable={false}
+      onMove={() => {}}
+      onReorder={() => {}}
+      overlay={() => null}
+    >
+      <SidebarContributionSection
+        entry={entry}
+        registry={registry}
+        navigator={{ open: vi.fn() } as unknown as Navigation}
+        target={target}
+        open
+        onToggle={() => {}}
+        groupIndex={0}
+        reorderable={false}
+        move={{}}
+      />
+    </ChannelSidebarDnd>,
+  );
+
+  expect(screen.getByRole("button", { name: /Useful item/ })).toBeVisible();
+  act(() => {
+    store.rows = [row, { id: "later", label: "Later item" }];
+    for (const listener of store.listeners) listener();
+  });
+  expect(screen.getByRole("button", { name: "Later item" })).toBeVisible();
+});
diff --git a/src/features/channel-navigation/SidebarContributionSection.tsx b/src/features/channel-navigation/SidebarContributionSection.tsx
new file mode 100644
index 0000000000..d4afc4b7f5
--- /dev/null
+++ b/src/features/channel-navigation/SidebarContributionSection.tsx
@@ -0,0 +1,245 @@
+import {
+  useCallback,
+  useLayoutEffect,
+  useState,
+  useSyncExternalStore,
+} from "react";
+import { IconButton } from "../../shared/design-system/ui/IconButton";
+import { NavigationItem } from "../../shared/design-system/ui/NavigationItem";
+import { OwnedContribution } from "../../plugins/OwnedContribution";
+import styles from "../../bundled/channels/Channels.module.css";
+import type { Navigation } from "../navigation/controller";
+import { targetKey, type OpenTarget } from "../navigation/targets";
+import type {
+  RegisteredSidebarSection,
+  SidebarSections,
+} from "./sidebar-sections-service";
+import { DroppableSidebarSection } from "./ChannelSidebarDnd";
+
+function isSelectedDestination(destination: OpenTarget, target: OpenTarget) {
+  const selectedKey = targetKey(target);
+  if (targetKey(destination) === selectedKey) return true;
+  if (
+    destination.kind === "conversation" &&
+    target.kind === "conversation" &&
+    destination.messageId === undefined &&
+    destination.panel === undefined
+  ) {
+    const conversationKey = (conversation: typeof destination) =>
+      targetKey({
+        version: 1,
+        kind: "conversation",
+        scope: conversation.scope,
+        channelId: conversation.channelId,
+      });
+    return conversationKey(destination) === conversationKey(target);
+  }
+  if (
+    destination.kind !== "page" ||
+    target.kind !== "page" ||
+    destination.scope !== undefined ||
+    target.scope === undefined ||
+    target.scope === null
+  )
+    return false;
+
+  // An omitted page scope retains the current community.
+  return targetKey({ ...destination, scope: target.scope }) === selectedKey;
+}
+
+export function SidebarContributionSection({
+  entry,
+  registry,
+  navigator,
+  target,
+  open,
+  onToggle,
+  groupIndex,
+  reorderable,
+  move,
+  onRowsCommitted,
+}: {
+  entry: RegisteredSidebarSection;
+  registry: SidebarSections;
+  navigator: Navigation;
+  target: OpenTarget;
+  open: boolean;
+  onToggle: (open: boolean) => void;
+  groupIndex: number;
+  reorderable: boolean;
+  move: { up?: () => void; down?: () => void } | undefined;
+  onRowsCommitted?: () => void;
+}) {
+  return (
+    <OwnedContribution
+      entry={entry}
+      registry={registry}
+      fallback={
+        <DroppableSidebarSection
+          disabled={false}
+          reorderable={reorderable}
+          groupIndex={groupIndex}
+          groupDomain="contributions"
+          sectionKey={`plugin:${entry.key}`}
+          title={entry.title}
+          open={open}
+          onToggle={onToggle}
+          move={move}
+          hideMoreActions={!reorderable}
+        >
+          <p role="alert">
+            {entry.title} is unavailable. Other sidebar sections remain
+            available.
+          </p>
+        </DroppableSidebarSection>
+      }
+    >
+      {(section, active) => (
+        <SectionContents
+          entry={section}
+          active={active}
+          navigator={navigator}
+          target={target}
+          open={open}
+          onToggle={onToggle}
+          groupIndex={groupIndex}
+          reorderable={reorderable}
+          move={move}
+          onRowsCommitted={onRowsCommitted}
+        />
+      )}
+    </OwnedContribution>
+  );
+}
+
+function SectionContents({
+  entry,
+  active,
+  navigator,
+  target,
+  open,
+  onToggle,
+  groupIndex,
+  reorderable,
+  move,
+  onRowsCommitted,
+}: {
+  entry: RegisteredSidebarSection;
+  active: () => boolean;
+  navigator: Navigation;
+  target: OpenTarget;
+  open: boolean;
+  onToggle: (open: boolean) => void;
+  groupIndex: number;
+  reorderable: boolean;
+  move: { up?: () => void; down?: () => void } | undefined;
+  onRowsCommitted: (() => void) | undefined;
+}) {
+  const subscribe = useCallback(
+    (listener: () => void) => entry.rows.subscribe(listener),
+    [entry.rows],
+  );
+  const snapshot = useCallback(() => entry.rows.snapshot(), [entry.rows]);
+  const rows = useSyncExternalStore(subscribe, snapshot, snapshot);
+  // The external-store update rerenders this child, not the reveal owner.
+  useLayoutEffect(() => {
+    onRowsCommitted?.();
+  });
+  const [actionError, setActionError] = useState(false);
+  if (!Array.isArray(rows)) throw new Error("Sidebar rows must be an array");
+  const ids = new Set<string>();
+  for (const row of rows) {
+    if (
+      !row ||
+      typeof row.id !== "string" ||
+      !row.id ||
+      ids.has(row.id) ||
+      typeof row.label !== "string" ||
+      !row.label.trim()
+    )
+      throw new Error("Sidebar rows need unique ids and non-empty labels");
+    ids.add(row.id);
+  }
+  const select = (destination: OpenTarget) => {
+    if (!active()) return;
+    setActionError(false);
+    try {
+      void navigator.open(destination).catch(() => setActionError(true));
+    } catch {
+      setActionError(true);
+    }
+  };
+  const actions = (entry.actions ?? []).map((action) => (
+    <IconButton
+      key={action.id}
+      size="compact"
+      aria-label={action.label}
+      title={action.label}
+      icon={action.icon}
+      onClick={() => {
+        if (!active()) return;
+        setActionError(false);
+        try {
+          void Promise.resolve(action.onSelect()).catch(() =>
+            setActionError(true),
+          );
+        } catch {
+          setActionError(true);
+        }
+      }}
+    />
+  ));
+  return (
+    <DroppableSidebarSection
+      groupDomain="contributions"
+      disabled={false}
+      reorderable={reorderable}
+      groupIndex={groupIndex}
+      sectionKey={`plugin:${entry.key}`}
+      title={entry.title}
+      icon={entry.icon}
+      open={open}
+      onToggle={onToggle}
+      move={move}
+      hideMoreActions={!reorderable}
+      headerActions={actions}
+      headerNotice={
+        actionError && (
+          <p className={styles.contributionFeedback} role="alert">
+            This sidebar action couldn’t finish.
+          </p>
+        )
+      }
+    >
+      {rows.map((row) => {
+        const trailing = [
+          row.badge,
+          typeof row.count === "number" && Number.isFinite(row.count)
+            ? new Intl.NumberFormat().format(row.count)
+            : undefined,
+          row.status,
+        ]
+          .filter((value) => typeof value === "string" && value.trim())
+          .join(" · ");
+        const destination = entry.select(row);
+        return (
+          <div key={row.id} className={styles.contributionNavigationItem}>
+            <NavigationItem
+              label={row.label}
+              icon={row.icon}
+              trailing={
+                trailing ? (
+                  <span className={styles.contributionMetadata}>
+                    {trailing}
+                  </span>
+                ) : undefined
+              }
+              selected={isSelectedDestination(destination, target)}
+              onClick={() => select(destination)}
+            />
+          </div>
+        );
+      })}
+    </DroppableSidebarSection>
+  );
+}
diff --git a/src/features/channel-navigation/sidebar-sections-service.test.ts b/src/features/channel-navigation/sidebar-sections-service.test.ts
new file mode 100644
index 0000000000..370712898d
--- /dev/null
+++ b/src/features/channel-navigation/sidebar-sections-service.test.ts
@@ -0,0 +1,93 @@
+import { Context } from "@deepseek-ai/cordis";
+import { afterEach, expect, it, vi } from "vitest";
+import { SidebarSectionsService } from "./sidebar-sections-service";
+
+const rows = {
+  snapshot: () => [{ id: "row", label: "Row" }],
+  subscribe: () => () => {},
+};
+const section = {
+  version: 1 as const,
+  id: "work",
+  title: "Work",
+  icon: "W",
+  rows,
+  select: () => ({ version: 1 as const, kind: "home" as const }),
+};
+
+function rootContext() {
+  const root = new Context();
+  root.provide("pluginStatus", {
+    isActive: () => true,
+    subscribe: () => () => {},
+  });
+  return root;
+}
+
+afterEach(() => vi.restoreAllMocks());
+
+it("registers a versioned section under its owner and disposes it with the plugin", async () => {
+  const root = rootContext();
+  const registry = new SidebarSectionsService(root);
+  const scope = root.extend({
+    pluginOwner: { id: "example.plugin", revision: "one" },
+  });
+  const fiber = scope.plugin((ctx) => ctx.sidebarSections?.register(section));
+  await fiber.await();
+
+  expect(registry.snapshot()).toMatchObject([
+    {
+      ...section,
+      key: "example.plugin/work",
+      pluginId: "example.plugin",
+      revision: "one",
+    },
+  ]);
+  await fiber.dispose();
+  expect(registry.snapshot()).toEqual([]);
+  await root.fiber.dispose();
+});
+
+it("ignores an unsupported contribution version without failing plugin activation", async () => {
+  const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+  const root = rootContext();
+  const registry = new SidebarSectionsService(root);
+  const applied = vi.fn();
+  const fiber = root
+    .extend({ pluginOwner: { id: "example.plugin", revision: "one" } })
+    .plugin((ctx) => {
+      ctx.reflect.get("sidebarSections")?.register({
+        ...section,
+        version: 2,
+      } as never);
+      applied();
+    });
+
+  await fiber.await();
+  expect(registry.snapshot()).toEqual([]);
+  expect(applied).toHaveBeenCalledOnce();
+  expect(warn).toHaveBeenCalledOnce();
+  await root.fiber.dispose();
+});
+
+it("lets a plugin use an older host that does not provide sidebar sections", async () => {
+  const root = new Context();
+  const registerPage = vi.fn();
+  root.provide("pages", { register: registerPage } as never);
+  const fiber = root
+    .extend({ pluginOwner: { id: "example.plugin", revision: "one" } })
+    .plugin((ctx) => {
+      ctx.reflect.get("sidebarSections")?.register(section);
+      ctx.pages.register({
+        id: "page",
+        title: "Page",
+        component: () => null,
+      });
+    });
+
+  await fiber.await();
+  expect(registerPage).toHaveBeenCalledWith(
+    expect.objectContaining({ id: "page", title: "Page" }),
+  );
+  await root.fiber.dispose();
+});
diff --git a/src/features/channel-navigation/sidebar-sections-service.ts b/src/features/channel-navigation/sidebar-sections-service.ts
new file mode 100644
index 0000000000..ae9d2675f0
--- /dev/null
+++ b/src/features/channel-navigation/sidebar-sections-service.ts
@@ -0,0 +1,100 @@
+import { Service, type Context } from "@deepseek-ai/cordis";
+import type { ReactElement, ReactNode } from "react";
+import type { OpenTarget } from "../navigation/targets";
+import {
+  createContributions,
+  type Contribution,
+} from "../../plugins/contributions.ts";
+
+export type SidebarSectionRow = Readonly<{
+  id: string;
+  label: string;
+  icon?: ReactNode;
+  badge?: string;
+  count?: number;
+  status?: string;
+}>;
+
+export type SidebarSectionAction = Readonly<{
+  id: string;
+  label: string;
+  icon: ReactElement;
+  onSelect: () => void | Promise<void>;
+}>;
+
+export type SidebarSectionContribution = Readonly<{
+  version: 1;
+  id: string;
+  title: string;
+  icon: ReactNode;
+  rows: Readonly<{
+    snapshot: () => readonly SidebarSectionRow[];
+    subscribe: (listener: () => void) => () => void;
+  }>;
+  select: (row: SidebarSectionRow) => OpenTarget;
+  actions?: readonly SidebarSectionAction[];
+}>;
+
+export type RegisteredSidebarSection = Contribution<SidebarSectionContribution>;
+export type SidebarSections = Readonly<{
+  version: 1;
+  snapshot: () => readonly RegisteredSidebarSection[];
+  subscribe: (listener: () => void) => () => void;
+  register: (section: SidebarSectionContribution) => void;
+}>;
+
+declare module "@deepseek-ai/cordis" {
+  interface Context {
+    /** Read with `ctx.reflect.get("sidebarSections")` for old-host compatibility. */
+    sidebarSections?: SidebarSections;
+  }
+}
+
+const idPattern = /^[a-z0-9][a-z0-9._-]*$/;
+
+export class SidebarSectionsService extends Service implements SidebarSections {
+  private readonly contributions;
+  readonly version = 1 as const;
+
+  constructor(ctx: Context) {
+    super(ctx, "sidebarSections");
+    this.contributions = createContributions<SidebarSectionContribution>(ctx);
+  }
+
+  snapshot = () => this.contributions.snapshot();
+  subscribe = (listener: () => void) => this.contributions.subscribe(listener);
+
+  register(section: SidebarSectionContribution) {
+    if (section?.version !== 1) {
+      console.warn("Ignoring unsupported sidebar section contribution version");
+      return;
+    }
+    if (
+      typeof section.id !== "string" ||
+      !idPattern.test(section.id) ||
+      typeof section.title !== "string" ||
+      !section.title.trim() ||
+      section.icon == null ||
+      !section.rows ||
+      typeof section.rows.snapshot !== "function" ||
+      typeof section.rows.subscribe !== "function" ||
+      typeof section.select !== "function" ||
+      (section.actions !== undefined &&
+        (!Array.isArray(section.actions) ||
+          section.actions.some(
+            (action) =>
+              !action ||
+              typeof action.id !== "string" ||
+              !idPattern.test(action.id) ||
+              typeof action.label !== "string" ||
+              !action.label.trim() ||
+              action.icon == null ||
+              typeof action.onSelect !== "function",
+          )))
+    )
+      throw new Error(
+        "A sidebar section needs an id, title, rows, and select action",
+      );
+    this.contributions.register(this.ctx, section);
+  }
+}
diff --git a/src/plugins/author.test.mjs b/src/plugins/author.test.mjs
index f54319c6de..4e86b7d4d9 100644
--- a/src/plugins/author.test.mjs
+++ b/src/plugins/author.test.mjs
@@ -32,7 +32,8 @@ test("generated author package in a path with spaces exposes shared message fact
     await writeFile(
       join(dir, "consumer.ts"),
       `
-import type { Context, DecisionResult, Host, PluginManifest, NamingPolicy, UnreadCapability, PageSidebarProps } from "@buzz/author";
+import { createElement } from "react";
+import type { Context, DecisionResult, Host, PluginManifest, NamingPolicy, PageSidebarProps, SidebarSectionContribution, SidebarSections, UnreadCapability } from "@buzz/author";
 export const manifest: PluginManifest = {
   id: "example.plugin", name: "Example", apiVersion: 1,
   host: {
@@ -92,6 +93,25 @@ export function apply(ctx: Context) {
     // @ts-expect-error A page sidebar must be a React component.
     sidebar: 1,
   });
+  const section: SidebarSectionContribution = {
+    version: 1,
+    id: "work",
+    title: "Work",
+    icon: "W",
+    rows: {
+      snapshot: () => [{ id: "today", label: "Today" }],
+      subscribe: () => () => {},
+    },
+    select: () => ({ version: 1, kind: "home" }),
+    actions: [{ id: "new", label: "New", icon: createElement("span"), onSelect: () => {} }],
+  };
+  const sidebar: SidebarSections | undefined = ctx.reflect.get("sidebarSections");
+  sidebar?.register(section);
+  // @ts-expect-error Sidebar contribution versions are explicit.
+  sidebar?.register({ ...section, version: 2 });
+  // @ts-expect-error Row counts are numeric, not display text.
+  const badCount: SidebarSectionContribution = { ...section, rows: { snapshot: () => [{ id: "bad", label: "Bad", count: "two" }], subscribe: () => () => {} } };
+  void badCount;
   ctx.pages.register({
     id: "other",
     title: "Other",
diff --git a/src/plugins/author.ts b/src/plugins/author.ts
index 97fce53814..457445ebf6 100644
--- a/src/plugins/author.ts
+++ b/src/plugins/author.ts
@@ -10,6 +10,12 @@ export type {
 export type { NamingIdentity } from "../features/identity-names/policy";
 export type { Browser, BrowserViewProps } from "../features/browser/api";
 export type { Page, PageSidebarProps, Pages } from "../features/pages/service";
+export type {
+  SidebarSectionAction,
+  SidebarSectionContribution,
+  SidebarSectionRow,
+  SidebarSections,
+} from "../features/channel-navigation/sidebar-sections-service";
 export type {
   Panel,
   Panels,
diff --git a/tests/browser/fixture.mjs b/tests/browser/fixture.mjs
index f385e068e3..662e5e3175 100644
--- a/tests/browser/fixture.mjs
+++ b/tests/browser/fixture.mjs
@@ -66,6 +66,7 @@ export const test = base.extend({
   sidebarIcons: [false, { option: true }],
   channelNames: [{}, { option: true }],
   expectedPageFailure: [false, { option: true }],
+  expectedSidebarIconFailure: [false, { option: true }],
   largeSidebar: [false, { option: true }],
   iconCongestion: [false, { option: true }],
   dmLabels: [false, { option: true }],
@@ -130,6 +131,7 @@ export const test = base.extend({
       sidebarIcons,
       channelNames,
       expectedPageFailure,
+      expectedSidebarIconFailure,
       largeSidebar,
       iconCongestion,
       dmLabels,
@@ -2706,6 +2708,10 @@ export const test = base.extend({
             !retiredConsole(message, index) &&
             !injectedSidebarFailure(message, index) &&
             !injectedGitHubFailure(message, index) &&
+            !(
+              expectedSidebarIconFailure &&
+              message.includes("Fixture sidebar icon failure")
+            ) &&
             !(
               expectedPageFailure &&
               message.includes("Fixture page render failure")
diff --git a/tests/browser/plugin-fixtures.tsx b/tests/browser/plugin-fixtures.tsx
index 1089034e8d..ce7d3da451 100644
--- a/tests/browser/plugin-fixtures.tsx
+++ b/tests/browser/plugin-fixtures.tsx
@@ -9,6 +9,7 @@ import type { PageProps } from "../../src/features/pages/service";
 import type { PageNavigation } from "../../src/features/navigation/service";
 import type { RelayData } from "../../src/features/relay/service";
 import { PanelSubview } from "../../src/features/panels/PanelSubview";
+import { FolderOpenIcon } from "../../src/shared/design-system/icons";
 import type { PanelProps } from "../../src/features/panels/service";
 import type { NotificationInput } from "../../src/features/notifications/service";
 
@@ -55,6 +56,7 @@ declare global {
     fixtureNavigation?: Navigation;
     fixtureNotify?: (input: NotificationInput) => Promise<boolean>;
     fixturePageBroken?: boolean;
+    fixtureSidebarWorkIconThrows?: boolean;
     fixtureSidebarRecovery?: boolean;
     delayFixture?: { started: boolean; release?: () => void };
     stopFixtureDependency?: () => Promise<void>;
@@ -121,7 +123,71 @@ function RetryPage() {
     </button>
   );
 }
+
+function SidebarWorkIcon() {
+  if (window.fixtureSidebarWorkIconThrows)
+    throw new Error("Fixture sidebar icon failure");
+  return <FolderOpenIcon aria-hidden="true" />;
+}
+
 export const fixturePlugins: readonly BundledPlugin[] = [
+  {
+    manifest: {
+      id: "fixture.sidebar-sections",
+      name: "Sidebar section fixture",
+      apiVersion: 1,
+    },
+    module: {
+      apply(ctx) {
+        const rows = [
+          {
+            id: "work",
+            label: "Queue",
+            badge: "New",
+            count: 2,
+            status: "Active",
+          },
+        ];
+        const listeners = new Set<() => void>();
+        ctx.reflect.get("sidebarSections")?.register({
+          version: 1,
+          id: "work",
+          title: "Workspace",
+          icon: <SidebarWorkIcon />,
+          rows: {
+            snapshot: () => rows,
+            subscribe(listener) {
+              listeners.add(listener);
+              return () => listeners.delete(listener);
+            },
+          },
+          select: () => ({
+            version: 1,
+            kind: "page",
+            pluginId: "buzz.channels",
+            pageId: "channels",
+          }),
+        });
+        const reviewRows = [{ id: "review", label: "Review queue item" }];
+        ctx.reflect.get("sidebarSections")?.register({
+          version: 1,
+          id: "review",
+          title: "Review queue",
+          icon: <FolderOpenIcon aria-hidden="true" />,
+          rows: {
+            snapshot: () => reviewRows,
+            subscribe: () => () => {},
+          },
+          select: () => ({
+            version: 1,
+            kind: "page",
+            pluginId: "buzz.channels",
+            pageId: "channels",
+          }),
+        });
+      },
+    },
+  },
   {
     manifest: {
       id: "fixture.page-placement",
diff --git a/tests/browser/sidebar-contributions.spec.mjs b/tests/browser/sidebar-contributions.spec.mjs
new file mode 100644
index 0000000000..a9b178ffaa
--- /dev/null
+++ b/tests/browser/sidebar-contributions.spec.mjs
@@ -0,0 +1,237 @@
+import { test as appTest } from "./fixture.mjs";
+import { test, expect } from "./playwright-test.mjs";
+import {
+  closeSettings,
+  openPage,
+  openSettings,
+  selectSettingsSection,
+  settleShellToggle,
+} from "./navigation.mjs";
+import { setPluginEnabled } from "./plugin-settings.mjs";
+
+appTest.use({ pluginFixtures: true });
+
+test.describe("plugin sidebar contributions", () => {
+  appTest(
+    "stay inside the existing Solo and Team rail",
+    async ({ page, app }, testInfo) => {
+      const title = "Sidebar section fixture";
+      const section = page.locator(
+        '[data-sidebar-section="plugin:fixture.sidebar-sections/work"]',
+      );
+      const toggle = page.locator("[data-shell-sidebar-toggle]");
+      const openSidebar = async () => {
+        await settleShellToggle(page);
+        if ((await toggle.getAttribute("aria-label"))?.startsWith("Show"))
+          await toggle.click();
+        await expect(toggle).toHaveAttribute("aria-expanded", "true");
+      };
+      await page.goto(app.origin);
+      await openPage(page, "Messages");
+
+      for (const [width, mode, fontSize] of [
+        [1440, "light", "16px"],
+        [1440, "dark", "20px"],
+        [390, "light", "20px"],
+        [390, "dark", "16px"],
+      ]) {
+        await page.setViewportSize({ width, height: 850 });
+        await page.evaluate(
+          ({ mode, fontSize }) => {
+            document.documentElement.setAttribute("data-color-mode", mode);
+            document.documentElement.style.fontSize = fontSize;
+          },
+          { mode, fontSize },
+        );
+        await openSidebar();
+        await expect(
+          page.getByRole("navigation", { name: "Solo conversations" }),
+        ).toBeVisible();
+
+        await openSettings(page);
+        await selectSettingsSection(page, "Manage plugins");
+        await setPluginEnabled(page, title, false);
+        await closeSettings(page);
+        await openSidebar();
+        await expect(section).toHaveCount(0);
+        await page.screenshot({
+          path: testInfo.outputPath(
+            `sidebar-contribution-before-${width}-${mode}-${fontSize}-${testInfo.project.name}.png`,
+          ),
+        });
+
+        await openSettings(page);
+        await selectSettingsSection(page, "Manage plugins");
+        await setPluginEnabled(page, title, true);
+        await closeSettings(page);
+        await openSidebar();
+        await expect(section).toBeVisible();
+        await expect(
+          section.getByRole("button", { name: "Queue" }),
+        ).toBeVisible();
+        if (width === 390) {
+          const label = section
+            .getByRole("button", { name: "Queue" })
+            .locator(".navigation-item-label");
+          await expect
+            .poll(() =>
+              label.evaluate(
+                (element) => element.scrollWidth <= element.clientWidth,
+              ),
+            )
+            .toBe(true);
+        }
+        const sectionHeader = section.locator("summary");
+        await sectionHeader.focus();
+        await page.keyboard.press("Space");
+        await expect(
+          section.getByRole("button", { name: "Queue" }),
+        ).toBeHidden();
+        await page.keyboard.press("Space");
+        await expect(
+          section.getByRole("button", { name: "Queue" }),
+        ).toBeVisible();
+        await sectionHeader.evaluate((element) => element.blur());
+        await sectionHeader.click();
+        await expect(
+          section.getByRole("button", { name: "Queue" }),
+        ).toBeHidden();
+        await sectionHeader.click();
+        await expect(
+          section.getByRole("button", { name: "Queue" }),
+        ).toBeVisible();
+        const sidebar = page.getByRole("complementary", {
+          name: "Sidebar",
+          exact: true,
+        });
+        await expect(
+          sidebar.getByRole("navigation", { name: "Solo conversations" }),
+        ).toBeVisible();
+        await expect(sidebar.getByRole("tab", { name: "Team" })).toBeVisible();
+        await expect(
+          page.locator('button[data-channel-id="alpha"]'),
+        ).toBeVisible();
+
+        const geometry = await sidebar.evaluate((panel) => {
+          const shell = panel.closest(".shell-sidebar");
+          const group = panel.querySelector(
+            '[data-sidebar-section="plugin:fixture.sidebar-sections/work"]',
+          );
+          if (
+            !(shell instanceof HTMLElement) ||
+            !(group instanceof HTMLElement)
+          )
+            throw new Error("Sidebar contribution geometry is unavailable");
+          const shellBox = shell.getBoundingClientRect();
+          const groupBox = group.getBoundingClientRect();
+          return {
+            noHorizontalOverflow: shell.scrollWidth <= shell.clientWidth,
+            contained:
+              groupBox.left >= shellBox.left &&
+              groupBox.right <= shellBox.right,
+          };
+        });
+        expect(geometry).toEqual({
+          noHorizontalOverflow: true,
+          contained: true,
+        });
+        await page.screenshot({
+          path: testInfo.outputPath(
+            `sidebar-contribution-after-${width}-${mode}-${fontSize}-${testInfo.project.name}.png`,
+          ),
+        });
+      }
+    },
+  );
+
+  appTest(
+    "shows a drag preview for contributed sections",
+    async ({ page, app }) => {
+      await page.goto(app.origin);
+      await openPage(page, "Messages");
+
+      const section = page.locator(
+        '[data-sidebar-section="plugin:fixture.sidebar-sections/work"]',
+      );
+      const header = section.locator("summary");
+      await expect(section).toBeVisible();
+      const bounds = await header.boundingBox();
+      if (!bounds)
+        throw new Error("Sidebar contribution header is unavailable");
+
+      const x = bounds.x + bounds.width / 2;
+      const y = bounds.y + bounds.height / 2;
+      await page.mouse.move(x, y);
+      await page.mouse.down();
+      await page.mouse.move(x + 12, y + 12, { steps: 3 });
+
+      await expect(section).toHaveAttribute("data-section-dragging");
+      await expect(page.getByText("Workspace", { exact: true })).toHaveCount(2);
+
+      await page.keyboard.press("Escape");
+      await page.mouse.up();
+      await expect(page.locator("[data-section-dragging]")).toHaveCount(0);
+    },
+  );
+
+  appTest.describe("failed section icon recovery", () => {
+    appTest.use({ expectedSidebarIconFailure: true });
+
+    appTest(
+      "contains a failed contributed icon while dragging its fallback section",
+      async ({ page, app }) => {
+        await page.addInitScript(() => {
+          window.fixtureSidebarWorkIconThrows = true;
+        });
+        await page.goto(app.origin);
+        await openPage(page, "Messages");
+
+        const sidebar = page.getByRole("complementary", {
+          name: "Sidebar",
+          exact: true,
+        });
+        const section = page.locator(
+          '[data-sidebar-section="plugin:fixture.sidebar-sections/work"]',
+        );
+        await expect(section).toContainText("Workspace is unavailable.");
+        await expect(
+          sidebar.getByRole("navigation", { name: "Solo conversations" }),
+        ).toBeVisible();
+
+        const failureCountBeforeDrag = app.report.consoleErrors.filter(
+          (message) => message.includes("Fixture sidebar icon failure"),
+        ).length;
+        const header = section.locator("summary");
+        const bounds = await header.boundingBox();
+        if (!bounds)
+          throw new Error("Failed contribution header is unavailable");
+
+        const x = bounds.x + bounds.width / 2;
+        const y = bounds.y + bounds.height / 2;
+        await page.mouse.move(x, y);
+        await page.mouse.down();
+        await page.mouse.move(x + 12, y + 12, { steps: 3 });
+
+        await expect(section).toHaveAttribute("data-section-dragging");
+        await expect(
+          sidebar.getByRole("navigation", { name: "Solo conversations" }),
+        ).toBeVisible();
+        await expect(
+          sidebar.getByText("Conversations couldn’t open."),
+        ).toHaveCount(0);
+        await expect
+          .poll(
+            () =>
+              app.report.consoleErrors.filter((message) =>
+                message.includes("Fixture sidebar icon failure"),
+              ).length,
+          )
+          .toBeGreaterThan(failureCountBeforeDrag);
+
+        await page.keyboard.press("Escape");
+        await page.mouse.up();
+        await expect(page.locator("[data-section-dragging]")).toHaveCount(0);
+      },
+    );
+  });
+});
diff --git a/tests/browser/sidebar-reveal.fixture.tsx b/tests/browser/sidebar-reveal.fixture.tsx
index f20e75af45..f640e26a9b 100644
--- a/tests/browser/sidebar-reveal.fixture.tsx
+++ b/tests/browser/sidebar-reveal.fixture.tsx
@@ -1,23 +1,74 @@
 import { useState } from "react";
 import { createRoot } from "react-dom/client";
 import { useSidebarView } from "../../src/bundled/channels/useSidebarView";
+import { SidebarContributionSection } from "../../src/features/channel-navigation/SidebarContributionSection";
+import { ChannelSidebarDnd } from "../../src/features/channel-navigation/ChannelSidebarDnd";
+import type { Navigation } from "../../src/features/navigation/controller";
+import type { OpenTarget } from "../../src/features/navigation/targets";
+import type {
+  RegisteredSidebarSection,
+  SidebarSectionRow,
+  SidebarSections,
+} from "../../src/features/channel-navigation/sidebar-sections-service";
 
 // The real sidebar view hook over a plain list with real layout. The page
 // controls when the hook is mounted, where it navigates, and when the
 // current entry renders, as a roster or an exact lookup would.
 type State = { mounted: boolean; at: string; rows: number[] };
 const rows = (count: number) => Array.from({ length: count }, (_, i) => i);
+const contributionTarget: OpenTarget = {
+  version: 1,
+  kind: "conversation",
+  scope: {
+    viewer: "a".repeat(64),
+    communityOrigin: "wss://relay.example",
+  },
+  channelId: "late",
+};
+let contributionRows: readonly SidebarSectionRow[] = [];
+const contributionListeners = new Set<() => void>();
+const contribution: RegisteredSidebarSection = {
+  version: 1,
+  id: "late",
+  title: "Late rows",
+  icon: "★",
+  rows: {
+    snapshot: () => contributionRows,
+    subscribe(listener) {
+      contributionListeners.add(listener);
+      return () => contributionListeners.delete(listener);
+    },
+  },
+  select: () => contributionTarget,
+  key: "fixture.sidebar/late",
+  pluginId: "fixture.sidebar",
+  revision: "one",
+};
+const registry: SidebarSections = {
+  version: 1,
+  snapshot: () => [contribution],
+  subscribe: () => () => {},
+  register: () => {},
+};
+const navigator = {
+  open: async () => ({ status: "opened" as const }),
+} as unknown as Navigation;
 declare global {
   interface Window {
     sidebar: {
       update(next: Partial<State>): void;
       rows: typeof rows;
+      publishContributionRows(next: readonly SidebarSectionRow[]): void;
     };
   }
 }
 
 function Sidebar({ at, rows }: Omit<State, "mounted">) {
   const view = useSidebarView("fixture", true, at);
+  const target =
+    at === "conversation:late"
+      ? contributionTarget
+      : ({ version: 1, kind: "home" } satisfies OpenTarget);
   return (
     <nav
       aria-label="Sidebar"
@@ -34,6 +85,25 @@ function Sidebar({ at, rows }: Omit<State, "mounted">) {
           Row {id}
         </div>
       ))}
+      <ChannelSidebarDnd
+        writable={false}
+        onMove={() => {}}
+        onReorder={() => {}}
+        overlay={() => null}
+      >
+        <SidebarContributionSection
+          entry={contribution}
+          registry={registry}
+          navigator={navigator}
+          target={target}
+          open
+          onToggle={() => {}}
+          groupIndex={0}
+          reorderable={false}
+          move={undefined}
+          onRowsCommitted={view.retryReveal}
+        />
+      </ChannelSidebarDnd>
     </nav>
   );
 }
@@ -47,6 +117,10 @@ function Harness() {
   window.sidebar = {
     update: (next) => setState((state) => ({ ...state, ...next })),
     rows,
+    publishContributionRows: (next) => {
+      contributionRows = next;
+      for (const listener of contributionListeners) listener();
+    },
   };
   return state.mounted ? <Sidebar at={state.at} rows={state.rows} /> : null;
 }
diff --git a/tests/browser/sidebar-reveal.spec.mjs b/tests/browser/sidebar-reveal.spec.mjs
index 0838a8a76e..ea1ef6804e 100644
--- a/tests/browser/sidebar-reveal.spec.mjs
+++ b/tests/browser/sidebar-reveal.spec.mjs
@@ -133,3 +133,69 @@ test("a user scroll before a delayed entry renders keeps that position for its d
   expect(await sidebar.evaluate((element) => element.scrollTop)).toBe(200);
   expect(errors).toEqual([]);
 });
+
+test("late contributed rows retry the sidebar reveal without moving the owner", async ({
+  page,
+}) => {
+  const { errors } = watchPageErrors(page);
+  await page.goto(url);
+  const sidebar = page.getByRole("navigation", {
+    name: "Sidebar",
+    exact: true,
+  });
+  await page.evaluate(() =>
+    window.sidebar.update({
+      mounted: true,
+      at: "conversation:late",
+      rows: window.sidebar.rows(50),
+    }),
+  );
+  const contributedRow = sidebar.getByRole("button", { name: "Late item" });
+  await expect(contributedRow).toHaveCount(0);
+
+  // This external-store publication rerenders SectionContents, not Sidebar.
+  await page.evaluate(() =>
+    window.sidebar.publishContributionRows([
+      { id: "late", label: "Late item" },
+    ]),
+  );
+  await expect(contributedRow).toBeInViewport({ ratio: 0.9 });
+  await expect(contributedRow).toHaveAttribute("aria-current", "page");
+  expect(errors).toEqual([]);
+});
+
+test("a user scroll before contributed rows arrive cancels their reveal", async ({
+  page,
+}) => {
+  const { errors } = watchPageErrors(page);
+  await page.goto(url);
+  const sidebar = page.getByRole("navigation", {
+    name: "Sidebar",
+    exact: true,
+  });
+  await page.evaluate(() =>
+    window.sidebar.update({
+      mounted: true,
+      at: "conversation:late",
+      rows: window.sidebar.rows(50),
+    }),
+  );
+  await sidebar.hover();
+  await page.mouse.wheel(0, 200);
+  await expect
+    .poll(() => sidebar.evaluate((element) => element.scrollTop))
+    .toBe(200);
+  await settle(page);
+
+  await page.evaluate(() =>
+    window.sidebar.publishContributionRows([
+      { id: "late", label: "Late item" },
+    ]),
+  );
+  const contributedRow = sidebar.getByRole("button", { name: "Late item" });
+  await expect(contributedRow).toHaveAttribute("aria-current", "page");
+  await settle(page);
+  expect(await sidebar.evaluate((element) => element.scrollTop)).toBe(200);
+  await expect(contributedRow).not.toBeInViewport();
+  expect(errors).toEqual([]);
+});