diff --git a/apps/app/src/components/plugin/PluginNavSidebarItems.test.tsx b/apps/app/src/components/plugin/PluginNavSidebarItems.test.tsx
index 55303fce25..e9a9a01aa1 100644
--- a/apps/app/src/components/plugin/PluginNavSidebarItems.test.tsx
+++ b/apps/app/src/components/plugin/PluginNavSidebarItems.test.tsx
@@ -6,11 +6,18 @@ import {
   render,
   screen,
   waitFor,
+  within,
 } from "@testing-library/react";
-import { useEffect, type ComponentType } from "react";
+import {
+  useEffect,
+  useState,
+  type ComponentType,
+  type MouseEvent as ReactMouseEvent,
+} from "react";
 import { createStore, Provider } from "jotai";
-import { MemoryRouter } from "react-router-dom";
+import { MemoryRouter, useLocation } from "react-router-dom";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
 import { CompactViewportOverrideProvider } from "@bb/shared-ui/hooks/use-compact-viewport";
 import { SidebarProvider } from "@/components/ui/sidebar.js";
 import {
@@ -18,12 +25,25 @@ import {
   setPluginSlotRegistrations,
   type PluginRegistrationSet,
 } from "@/lib/plugin-slots";
+import {
+  AUTOMATIONS_PLUGIN_ID,
+  getPluginPanelRoutePath,
+} from "@/lib/route-paths";
 import {
   resetAllCrashedPluginSlotsForTest,
   resetCrashedPluginSlots,
 } from "./PluginSlotMount";
-import { PluginNavSidebarItems } from "./PluginNavSidebarItems";
-import { pluginNavPanelOrderAtom } from "./pluginNavSidebarAtoms";
+import {
+  type BuiltInSidebarNavEntry,
+  ExtensionsNavSidebarItem,
+  PluginNavSidebarItems,
+} from "./PluginNavSidebarItems";
+import {
+  pluginNavPanelOrderAtom,
+  pluginNavVisiblePanelKeysAtom,
+} from "./pluginNavSidebarAtoms";
+import { splitLayoutAtom } from "@/lib/split-layout/atoms";
+import { countPanes, findPaneByContent } from "@/lib/split-layout";
 
 function registrationSet(
   overrides: Partial<PluginRegistrationSet>,
@@ -66,39 +86,125 @@ function registerPanel(
   );
 }
 
-function renderSidebarItems(
-  options: {
-    toolsRoutePath?: string;
-    storedOrder?: string[];
-    compactViewport?: boolean;
-  } = {},
-) {
+interface RenderSidebarItemsOptions {
+  builtInEntries?: readonly BuiltInSidebarNavEntry[];
+  storedOrder?: string[];
+  storedVisibleKeys?: string[] | null;
+  compactViewport?: boolean;
+  compactCustomizeMode?: boolean;
+  onCompactCustomizeModeChange?: (isCustomizing: boolean) => void;
+  splitEnabled?: boolean;
+}
+
+function PluginNavSidebarItemsHarness({
+  options,
+}: {
+  options: RenderSidebarItemsOptions;
+}) {
+  const [compactCustomizeMode, setCompactCustomizeMode] = useState(
+    options.compactCustomizeMode ?? false,
+  );
+  const compactControlProps = options.compactViewport
+    ? {
+        compactCustomizeMode,
+        onCompactCustomizeModeChange: (isCustomizing: boolean) => {
+          setCompactCustomizeMode(isCustomizing);
+          options.onCompactCustomizeModeChange?.(isCustomizing);
+        },
+      }
+    : {};
+
+  return (
+    <PluginNavSidebarItems
+      builtInEntries={options.builtInEntries}
+      splitEnabled={options.splitEnabled}
+      {...compactControlProps}
+    />
+  );
+}
+
+function renderSidebarItems(options: RenderSidebarItemsOptions = {}) {
   const store = createStore();
+  const queryClient = new QueryClient({
+    defaultOptions: { queries: { retry: false } },
+  });
   if (options.storedOrder) {
     store.set(pluginNavPanelOrderAtom, options.storedOrder);
   }
-  return render(
+  if ("storedVisibleKeys" in options) {
+    store.set(
+      pluginNavVisiblePanelKeysAtom,
+      options.storedVisibleKeys ?? null,
+    );
+  }
+  if (options.splitEnabled) {
+    store.set(splitLayoutAtom, {
+      root: {
+        type: "pane",
+        paneId: "pane-1",
+        content: { kind: "new-thread" },
+      },
+      focusedPaneId: "pane-1",
+    });
+  }
+  const view = render(
     <CompactViewportOverrideProvider
       isCompactViewport={options.compactViewport ?? false}
     >
-      <Provider store={store}>
-        <MemoryRouter initialEntries={["/"]}>
-          <SidebarProvider>
-            <PluginNavSidebarItems toolsRoutePath={options.toolsRoutePath} />
-          </SidebarProvider>
-        </MemoryRouter>
-      </Provider>
+      <QueryClientProvider client={queryClient}>
+        <Provider store={store}>
+          <MemoryRouter initialEntries={["/"]}>
+            <SidebarProvider>
+              <PluginNavSidebarItemsHarness options={options} />
+              <LocationProbe />
+            </SidebarProvider>
+          </MemoryRouter>
+        </Provider>
+      </QueryClientProvider>
     </CompactViewportOverrideProvider>,
   );
+  return { ...view, store };
 }
 
-const ROW_LABELS = new Set(["Extensions", "Docs", "GitHub"]);
+function LocationProbe() {
+  return <output data-testid="location-path">{useLocation().pathname}</output>;
+}
+
+function panelRowNames(labels: readonly string[] = ["Docs", "GitHub"]): string[] {
+  const rowLabels = new Set(labels);
+  const container = screen.queryByTestId("plugin-nav-sidebar-items");
+  if (!container) return [];
+  return Array.from(
+    container.querySelectorAll<HTMLElement>("[data-sidebar-navigation-item]"),
+  )
+    .map((row) => row.textContent?.trim() ?? "")
+    .filter((label) => rowLabels.has(label));
+}
 
-function panelRowNames(): string[] {
-  return screen
-    .getAllByRole("button")
-    .map((button) => button.textContent?.trim() ?? "")
-    .filter((label) => ROW_LABELS.has(label));
+function builtInEntry(
+  id: string,
+  title: string,
+  onActivate: (
+    event: ReactMouseEvent<HTMLButtonElement>,
+  ) => void = vi.fn(),
+): BuiltInSidebarNavEntry {
+  return {
+    kind: "built-in",
+    pluginId: "__bb__",
+    id,
+    title,
+    icon: <span aria-hidden="true" />,
+    content: <button type="button">{title}</button>,
+    onActivate,
+  };
+}
+
+function customizeRows(): HTMLElement[] {
+  return Array.from(
+    screen
+      .getByRole("list", { name: "Sidebar navigation" })
+      .querySelectorAll<HTMLElement>("[data-plugin-nav-customize-item]"),
+  );
 }
 
 beforeEach(() => {
@@ -117,6 +223,27 @@ afterEach(() => {
 });
 
 describe("PluginNavSidebarItems", () => {
+  it("collapses the entire subsection with zero traditional plugins", () => {
+    renderSidebarItems();
+
+    expect(screen.queryByTestId("plugin-nav-sidebar-items")).toBeNull();
+    expect(screen.queryByText("Plugins")).toBeNull();
+  });
+
+  it("shows one plugin with a unified customization entry point and no section label", () => {
+    registerPanel("docs", "Docs");
+    renderSidebarItems();
+
+    expect(screen.queryByText("Plugins")).toBeNull();
+    expect(panelRowNames(["Docs"])).toEqual(["Docs"]);
+    expect(
+      screen.queryByTestId("plugin-nav-sidebar-overflow-toggle"),
+    ).toBeNull();
+    expect(
+      screen.getByRole("button", { name: "Customize sidebar navigation" }),
+    ).not.toBeNull();
+  });
+
   it("keeps an accessory-less plugin row unchanged", () => {
     registerPanel("docs", "Docs");
 
@@ -214,6 +341,10 @@ describe("PluginNavSidebarItems", () => {
     expect(
       await screen.findByRole("menuitem", { name: "Hide from sidebar" }),
     ).not.toBeNull();
+    expect(screen.queryByRole("menuitem", { name: "Move to top" })).toBeNull();
+    expect(
+      screen.queryByRole("menuitem", { name: "Move to overflow" }),
+    ).toBeNull();
 
     expect(accessory?.getAttribute("data-sidebar-hover-actions-open")).toBe(
       "true",
@@ -237,6 +368,111 @@ describe("PluginNavSidebarItems", () => {
     ).toBeNull();
   });
 
+  it("uses an in-place customization mode instead of a drawer on compact viewports", () => {
+    const onCompactCustomizeModeChange = vi.fn();
+    renderSidebarItems({
+      compactViewport: true,
+      builtInEntries: [
+        builtInEntry("new-thread", "New thread"),
+        builtInEntry("search-threads", "Search threads"),
+      ],
+      onCompactCustomizeModeChange,
+    });
+
+    fireEvent.click(
+      screen.getByRole("button", { name: "Customize sidebar navigation" }),
+    );
+
+    expect(onCompactCustomizeModeChange).toHaveBeenCalledWith(true);
+    expect(
+      screen.getByTestId("sidebar-navigation-customize-inline"),
+    ).not.toBeNull();
+    expect(screen.queryByRole("dialog")).toBeNull();
+    expect(screen.getByRole("button", { name: "Back to sidebar" })).toBe(
+      document.activeElement,
+    );
+    expect(
+      screen.queryByRole("button", { name: "Customize sidebar navigation" }),
+    ).toBeNull();
+    const firstCustomizeRow = customizeRows()[0];
+    const firstDragHandle = firstCustomizeRow?.querySelector<HTMLElement>(
+      "[data-plugin-nav-customize-drag-handle]",
+    );
+    const firstCheckbox = within(firstCustomizeRow as HTMLElement).getByRole(
+      "checkbox",
+    );
+    expect(
+      firstCustomizeRow?.classList.contains("max-md:pointer-coarse:h-9"),
+    ).toBe(true);
+    expect(
+      firstDragHandle?.classList.contains("max-md:pointer-coarse:h-9"),
+    ).toBe(true);
+    expect(
+      firstDragHandle?.classList.contains("max-md:pointer-coarse:w-9"),
+    ).toBe(true);
+    expect(
+      firstCheckbox
+        .closest("label")
+        ?.classList.contains("max-md:pointer-coarse:h-9"),
+    ).toBe(true);
+
+    fireEvent.click(screen.getByRole("button", { name: "Back to sidebar" }));
+
+    expect(onCompactCustomizeModeChange).toHaveBeenLastCalledWith(false);
+    expect(
+      screen.queryByTestId("sidebar-navigation-customize-inline"),
+    ).toBeNull();
+    expect(screen.getByRole("button", { name: "New thread" })).not.toBeNull();
+    expect(
+      screen.getByRole("button", { name: "Customize sidebar navigation" }),
+    ).toBe(document.activeElement);
+  });
+
+  it("keeps compact visibility changes in place and closes the mode when launching", () => {
+    const onActivate = vi.fn();
+    const { store } = renderSidebarItems({
+      compactViewport: true,
+      builtInEntries: [builtInEntry("new-thread", "New thread", onActivate)],
+    });
+
+    fireEvent.click(
+      screen.getByRole("button", { name: "Customize sidebar navigation" }),
+    );
+    fireEvent.click(
+      screen.getByRole("checkbox", { name: "Show New thread in sidebar" }),
+    );
+
+    expect(
+      screen.getByTestId("sidebar-navigation-customize-inline"),
+    ).not.toBeNull();
+    expect(store.get(pluginNavVisiblePanelKeysAtom)).toEqual([]);
+
+    fireEvent.click(screen.getByRole("button", { name: "New thread" }));
+
+    expect(onActivate).toHaveBeenCalledTimes(1);
+    expect(
+      screen.queryByTestId("sidebar-navigation-customize-inline"),
+    ).toBeNull();
+    expect(screen.queryByRole("checkbox")).toBeNull();
+  });
+
+  it("keeps the desktop customization popover", () => {
+    renderSidebarItems({
+      builtInEntries: [builtInEntry("new-thread", "New thread")],
+    });
+
+    fireEvent.click(
+      screen.getByRole("button", { name: "Customize sidebar navigation" }),
+    );
+
+    expect(
+      screen.getByRole("list", { name: "Sidebar navigation" }),
+    ).not.toBeNull();
+    expect(
+      screen.queryByTestId("sidebar-navigation-customize-inline"),
+    ).toBeNull();
+  });
+
   it("hides a crashed accessory and retries it after a plugin reload", () => {
     function CrashingAccessory(): never {
       throw new Error("accessory crashed");
@@ -257,158 +493,370 @@ describe("PluginNavSidebarItems", () => {
     expect(screen.queryByText("plugin tasks crashed")).toBeNull();
   });
 
-  it("moves a hidden panel into an expanded More disclosure and back", async () => {
-    registerPanel("docs", "Docs");
-    registerPanel("github", "GitHub");
+  it("shows only the first three plugins directly and lists every plugin in the menu", () => {
+    const labels = ["One", "Two", "Three", "Four", "Five", "Six"];
+    labels.forEach((label, index) => registerPanel(`plugin-${index}`, label));
 
     renderSidebarItems();
 
-    expect(panelRowNames()).toEqual(["Docs", "GitHub"]);
+    expect(panelRowNames(labels)).toEqual(labels.slice(0, 3));
     expect(
       screen.queryByTestId("plugin-nav-sidebar-overflow-toggle"),
     ).toBeNull();
 
-    fireEvent.pointerDown(
-      screen.getByRole("button", { name: "Docs panel options" }),
-      { button: 0 },
-    );
     fireEvent.click(
-      await screen.findByRole("menuitem", { name: "Hide from sidebar" }),
+      screen.getByRole("button", { name: "Customize sidebar navigation" }),
+    );
+    expect(customizeRows().map((row) => row.textContent?.trim())).toEqual(
+      labels,
     );
+    expect(
+      screen.queryByRole("button", { name: "Four panel options" }),
+    ).toBeNull();
+  });
 
-    await waitFor(() => {
-      expect(
-        screen.getByTestId("plugin-nav-sidebar-overflow-toggle").textContent,
-      ).toContain("More (1)");
+  it("keeps built-ins visible without letting their order consume plugin slots", () => {
+    const labels = ["One", "Two", "Three", "Four"];
+    labels.forEach((label, index) => registerPanel(`plugin-${index}`, label));
+    renderSidebarItems({
+      builtInEntries: [
+        builtInEntry("new-thread", "New thread"),
+        builtInEntry("search-threads", "Search threads"),
+      ],
+      storedOrder: [
+        "plugin-0/main",
+        "__bb__/new-thread",
+        "plugin-1/main",
+        "__bb__/search-threads",
+        "plugin-2/main",
+        "plugin-3/main",
+      ],
     });
-    expect(panelRowNames()).toEqual(["GitHub"]);
+
     expect(
-      window.localStorage.getItem("bb.sidebar.hiddenPluginPanels"),
-    ).toContain("docs/main");
+      Array.from(
+        screen
+          .getByTestId("plugin-nav-sidebar-items")
+          .querySelectorAll("[data-sidebar-navigation-item]"),
+      ).map((row) => row.getAttribute("data-sidebar-navigation-item")),
+    ).toEqual([
+      "plugin-0/main",
+      "__bb__/new-thread",
+      "plugin-1/main",
+      "__bb__/search-threads",
+      "plugin-2/main",
+    ]);
+  });
+
+  it("keeps launch and visibility as distinct targets with a clear row hover state", async () => {
+    const labels = ["One", "Two", "Three", "Four"];
+    labels.forEach((label, index) => registerPanel(`plugin-${index}`, label));
+    const { store, unmount } = renderSidebarItems();
 
-    fireEvent.click(screen.getByTestId("plugin-nav-sidebar-overflow-toggle"));
-    await waitFor(() => {
-      expect(panelRowNames()).toEqual(["GitHub", "Docs"]);
+    const trigger = screen.getByRole("button", {
+      name: "Customize sidebar navigation",
     });
+    expect(trigger.querySelector("svg")).not.toBeNull();
 
-    fireEvent.pointerDown(
-      screen.getByRole("button", { name: "Docs panel options" }),
-      { button: 0 },
+    fireEvent.click(trigger);
+    const choices = screen.getAllByRole("checkbox");
+    await waitFor(() =>
+      expect(
+        document.activeElement?.getAttribute(
+          "data-sidebar-navigation-customize-launch",
+        ),
+      ).toBe("plugin-0/main"),
     );
-    fireEvent.click(
-      await screen.findByRole("menuitem", { name: "Show in sidebar" }),
+    expect(choices.map((choice) => choice.getAttribute("data-state"))).toEqual([
+      "checked",
+      "checked",
+      "checked",
+      "unchecked",
+    ]);
+    expect(
+      document.querySelectorAll("[data-plugin-nav-customize-drag-handle]"),
+    ).toHaveLength(4);
+    expect(customizeRows()[0]?.classList.contains("hover:bg-state-hover")).toBe(
+      true,
     );
 
-    await waitFor(() => {
-      expect(
-        screen.queryByTestId("plugin-nav-sidebar-overflow-toggle"),
-      ).toBeNull();
-    });
-    expect(panelRowNames()).toEqual(["Docs", "GitHub"]);
-  });
-
-  it("collapses hidden panels behind the More toggle on a later mount", async () => {
-    registerPanel("docs", "Docs");
-    registerPanel("github", "GitHub");
-    window.localStorage.setItem(
-      "bb.sidebar.hiddenPluginPanels",
-      JSON.stringify(["docs/main"]),
-    );
+    fireEvent.click(choices[0]!);
+    expect(
+      screen.getByRole("list", { name: "Sidebar navigation" }),
+    ).not.toBeNull();
+    expect(store.get(pluginNavVisiblePanelKeysAtom)).toEqual([
+      "plugin-1/main",
+      "plugin-2/main",
+    ]);
+    expect(panelRowNames(labels)).toEqual(["Two", "Three"]);
 
+    unmount();
     renderSidebarItems();
+    expect(panelRowNames(labels)).toEqual(["Two", "Three"]);
+    fireEvent.click(
+      screen.getByRole("button", { name: "Customize sidebar navigation" }),
+    );
 
-    expect(panelRowNames()).toEqual(["GitHub"]);
-    const toggle = screen.getByTestId("plugin-nav-sidebar-overflow-toggle");
-    expect(toggle.textContent).toContain("More (1)");
+    const hiddenRow = document.querySelector<HTMLElement>(
+      '[data-plugin-nav-customize-item="plugin-0/main"]',
+    );
+    expect(hiddenRow).not.toBeNull();
+    fireEvent.click(
+      within(hiddenRow as HTMLElement).getByRole("button", { name: "One" }),
+    );
 
-    fireEvent.click(toggle);
-    await waitFor(() => {
-      expect(panelRowNames()).toEqual(["GitHub", "Docs"]);
-    });
+    expect(screen.getByTestId("location-path").textContent).toBe(
+      getPluginPanelRoutePath({ pluginId: "plugin-0", path: "main" }),
+    );
+    await waitFor(() =>
+      expect(
+        screen.queryByRole("list", { name: "Sidebar navigation" }),
+      ).toBeNull(),
+    );
   });
 
-  it("hides the built-in Extensions row like a plugin row", async () => {
+  it("seeds newly introduced built-ins without overriding existing plugin visibility", () => {
     registerPanel("docs", "Docs");
+    registerPanel("tasks", "Tasks");
+    renderSidebarItems({
+      builtInEntries: [
+        builtInEntry("new-thread", "New thread"),
+        builtInEntry("search-threads", "Search threads"),
+      ],
+      storedOrder: ["tasks/main", "docs/main"],
+      storedVisibleKeys: ["docs/main"],
+    });
 
-    renderSidebarItems({ toolsRoutePath: "/extensions/skills" });
+    expect(
+      Array.from(
+        screen
+          .getByTestId("plugin-nav-sidebar-items")
+          .querySelectorAll("[data-sidebar-navigation-item]"),
+      ).map((row) => row.getAttribute("data-sidebar-navigation-item")),
+    ).toEqual(["__bb__/new-thread", "__bb__/search-threads", "docs/main"]);
+  });
 
-    expect(panelRowNames()).toEqual(["Extensions", "Docs"]);
+  it("keeps Customize on the New thread row without stranding it when the row is hidden", () => {
+    renderSidebarItems({
+      builtInEntries: [
+        builtInEntry("new-thread", "New thread"),
+        builtInEntry("search-threads", "Search threads"),
+      ],
+    });
 
-    fireEvent.pointerDown(
-      screen.getByRole("button", { name: "Extensions panel options" }),
-      { button: 0 },
-    );
+    const trigger = screen.getByRole("button", {
+      name: "Customize sidebar navigation",
+    });
+    expect(
+      trigger
+        .closest("[data-sidebar-navigation-item]")
+        ?.getAttribute("data-sidebar-navigation-item"),
+    ).toBe("__bb__/new-thread");
+
+    fireEvent.click(trigger);
     fireEvent.click(
-      await screen.findByRole("menuitem", { name: "Hide from sidebar" }),
+      screen.getByRole("checkbox", { name: "Show New thread in sidebar" }),
     );
 
-    await waitFor(() => {
-      expect(panelRowNames()).toEqual(["Docs"]);
-    });
     expect(
-      screen.getByTestId("plugin-nav-sidebar-overflow-toggle").textContent,
-    ).toContain("More (1)");
+      screen.getByRole("list", { name: "Sidebar navigation" }),
+    ).not.toBeNull();
     expect(
-      window.localStorage.getItem("bb.sidebar.hiddenPluginPanels"),
-    ).toContain("__builtin__/tools");
+      screen
+        .getByRole("button", { name: "Customize sidebar navigation" })
+        .closest("[data-sidebar-navigation-item]"),
+    ).toBeNull();
   });
 
-  it("keeps Extensions on top for users who already reordered their plugin rows", () => {
-    registerPanel("docs", "Docs");
-    registerPanel("github", "GitHub");
-
+  it("applies one persisted mixed order to direct rows and the menu", () => {
+    const labels = ["One", "Two", "Three", "Four"];
+    labels.forEach((label, index) => registerPanel(`plugin-${index}`, label));
+    const newThread = builtInEntry("new-thread", "New thread");
+    const searchThreads = builtInEntry("search-threads", "Search threads");
     renderSidebarItems({
-      toolsRoutePath: "/extensions/skills",
-      storedOrder: ["github/main", "docs/main"],
+      builtInEntries: [newThread, searchThreads],
+      storedOrder: [
+        "plugin-3/main",
+        "__bb__/search-threads",
+        "plugin-1/main",
+        "__bb__/new-thread",
+        "plugin-0/main",
+        "plugin-2/main",
+      ],
+      storedVisibleKeys: [
+        "plugin-3/main",
+        "__bb__/search-threads",
+        "__bb__/new-thread",
+        "plugin-0/main",
+      ],
     });
 
-    expect(panelRowNames()).toEqual(["Extensions", "GitHub", "Docs"]);
+    expect(
+      Array.from(
+        screen
+          .getByTestId("plugin-nav-sidebar-items")
+          .querySelectorAll("[data-sidebar-navigation-item]"),
+      ).map((row) => row.getAttribute("data-sidebar-navigation-item")),
+    ).toEqual([
+      "plugin-3/main",
+      "__bb__/search-threads",
+      "__bb__/new-thread",
+      "plugin-0/main",
+    ]);
+
+    fireEvent.click(
+      screen.getByRole("button", { name: "Customize sidebar navigation" }),
+    );
+    expect(customizeRows().map((row) => row.textContent?.trim())).toEqual([
+      "Four",
+      "Search threads",
+      "Two",
+      "New thread",
+      "One",
+      "Three",
+    ]);
+    expect(
+      screen
+        .getAllByRole("checkbox")
+        .map((choice) => choice.getAttribute("data-state")),
+    ).toEqual([
+      "checked",
+      "checked",
+      "unchecked",
+      "checked",
+      "checked",
+      "unchecked",
+    ]);
   });
 
-  it("keeps a saved order when plugin frontends register after the first render", async () => {
+  it("launches a built-in row from the menu without changing its visibility", async () => {
+    const onActivate = vi.fn();
     renderSidebarItems({
-      toolsRoutePath: "/extensions/skills",
-      storedOrder: ["github/main", "__builtin__/tools", "docs/main"],
+      builtInEntries: [builtInEntry("new-thread", "New thread", onActivate)],
     });
 
-    expect(panelRowNames()).toEqual(["Extensions"]);
+    fireEvent.click(
+      screen.getByRole("button", { name: "Customize sidebar navigation" }),
+    );
+    const row = customizeRows()[0];
+    expect(row).toBeDefined();
+    fireEvent.click(
+      within(row as HTMLElement).getByRole("button", { name: "New thread" }),
+    );
 
-    registerPanel("docs", "Docs");
-    registerPanel("github", "GitHub");
+    expect(onActivate).toHaveBeenCalledTimes(1);
+    await waitFor(() =>
+      expect(
+        screen.queryByRole("list", { name: "Sidebar navigation" }),
+      ).toBeNull(),
+    );
+  });
 
-    await waitFor(() => {
-      expect(panelRowNames()).toEqual(["GitHub", "Extensions", "Docs"]);
+  it("preserves modifier-click when launching a built-in from Customize", async () => {
+    const onActivate = vi.fn();
+    renderSidebarItems({
+      builtInEntries: [builtInEntry("new-thread", "New thread", onActivate)],
     });
+
+    fireEvent.click(
+      screen.getByRole("button", { name: "Customize sidebar navigation" }),
+    );
+    const row = customizeRows()[0];
+    expect(row).toBeDefined();
+    fireEvent.click(
+      within(row as HTMLElement).getByRole("button", { name: "New thread" }),
+      { metaKey: true },
+    );
+
+    expect(onActivate).toHaveBeenCalledOnce();
+    expect(onActivate.mock.calls[0]?.[0]).toMatchObject({ metaKey: true });
+    await waitFor(() =>
+      expect(
+        screen.queryByRole("list", { name: "Sidebar navigation" }),
+      ).toBeNull(),
+    );
   });
 
-  it("saves no Extensions key while the row is absent", async () => {
+  it("preserves modifier-click when launching a plugin from Customize", async () => {
     registerPanel("docs", "Docs");
+    const { store } = renderSidebarItems({ splitEnabled: true });
 
-    renderSidebarItems({ storedOrder: ["docs/main"] });
+    fireEvent.click(
+      screen.getByRole("button", { name: "Customize sidebar navigation" }),
+    );
+    const row = customizeRows()[0];
+    expect(row).toBeDefined();
+    fireEvent.click(
+      within(row as HTMLElement).getByRole("button", { name: "Docs" }),
+      { metaKey: true },
+    );
 
-    await waitFor(() => {
-      expect(panelRowNames()).toEqual(["Docs"]);
-    });
+    const layout = store.get(splitLayoutAtom);
+    expect(layout).not.toBeNull();
+    expect(countPanes(layout!.root)).toBe(2);
     expect(
-      window.localStorage.getItem("bb.sidebar.pluginPanelOrder") ?? "",
-    ).not.toContain("__builtin__/tools");
+      findPaneByContent(layout!.root, {
+        kind: "plugin-panel",
+        pluginId: "docs",
+        panelPath: "main",
+        subPath: "",
+      }),
+    ).not.toBeNull();
+    await waitFor(() =>
+      expect(
+        screen.queryByRole("list", { name: "Sidebar navigation" }),
+      ).toBeNull(),
+    );
   });
 
-  it("carries both Extensions glyphs so hover swaps without reflow", () => {
-    renderSidebarItems({ toolsRoutePath: "/extensions/plugins" });
+  it("keeps Automations on the plugin row contract with a unified identity", () => {
+    registerPanel(AUTOMATIONS_PLUGIN_ID, "Automations", () => (
+      <span>Scheduled</span>
+    ));
+    const view = renderSidebarItems({ splitEnabled: true });
 
-    const extensionsRow = screen
-      .getAllByRole("button")
-      .find((button) => button.textContent?.trim() === "Extensions");
-    expect(extensionsRow).toBeTruthy();
+    expect(
+      view.container.querySelector(
+        '[data-sidebar-navigation-item="__bb__/automations"]',
+      ),
+    ).not.toBeNull();
+    expect(
+      screen.getByRole("button", { name: "Automations panel options" }),
+    ).not.toBeNull();
+    expect(
+      view.container.querySelector("[data-plugin-nav-sidebar-accessory]")
+        ?.textContent,
+    ).toBe("Scheduled");
 
-    const swap = extensionsRow?.querySelector(".bb-sidebar-row-icon-swap");
-    expect(swap).toBeTruthy();
+    fireEvent.click(screen.getByRole("button", { name: "Automations" }), {
+      metaKey: true,
+    });
+    const layout = view.store.get(splitLayoutAtom);
+    expect(layout).not.toBeNull();
+    expect(countPanes(layout!.root)).toBe(2);
     expect(
-      swap?.querySelector('.bb-sidebar-row-icon-rest[data-icon="Toolbox"]'),
-    ).toBeTruthy();
+      findPaneByContent(layout!.root, {
+        kind: "plugin-panel",
+        pluginId: AUTOMATIONS_PLUGIN_ID,
+        panelPath: "main",
+        subPath: "",
+      }),
+    ).not.toBeNull();
+  });
+});
+
+describe("ExtensionsNavSidebarItem", () => {
+  it("is host-owned and has no plugin-panel options menu", () => {
+    render(
+      <MemoryRouter>
+        <ExtensionsNavSidebarItem routePath="/extensions/plugins" />
+      </MemoryRouter>,
+    );
+
+    const row = screen.getByRole("button", { name: "Extensions" });
+    expect(row.querySelector(".bb-sidebar-row-icon-swap")).not.toBeNull();
     expect(
-      swap?.querySelector('.bb-sidebar-row-icon-hover[data-icon="ToolCase"]'),
-    ).toBeTruthy();
+      screen.queryByRole("button", { name: "Extensions panel options" }),
+    ).toBeNull();
   });
 });
diff --git a/apps/app/src/components/plugin/PluginNavSidebarItems.tsx b/apps/app/src/components/plugin/PluginNavSidebarItems.tsx
index ac9082188b..c7c435778a 100644
--- a/apps/app/src/components/plugin/PluginNavSidebarItems.tsx
+++ b/apps/app/src/components/plugin/PluginNavSidebarItems.tsx
@@ -1,7 +1,9 @@
 import {
   useCallback,
   useEffect,
+  useId,
   useMemo,
+  useRef,
   useState,
   type CSSProperties,
   type MouseEvent as ReactMouseEvent,
@@ -11,11 +13,14 @@ import {
 import { useLocation, useNavigate } from "react-router-dom";
 import { useAtom } from "jotai";
 import { DndContext, type DragEndEvent } from "@dnd-kit/core";
+import { FilterHorizontalIcon } from "@hugeicons/core-free-icons";
+import { HugeiconsIcon } from "@hugeicons/react";
 import {
   SortableContext,
   verticalListSortingStrategy,
 } from "@dnd-kit/sortable";
 import { Button } from "@bb/shared-ui/button";
+import { Checkbox } from "@bb/shared-ui/checkbox";
 import { Icon } from "@bb/shared-ui/icon";
 import {
   ContextMenu,
@@ -29,19 +34,36 @@ import {
   DropdownMenuItem,
   DropdownMenuTrigger,
 } from "@bb/shared-ui/dropdown-menu";
-import { COARSE_POINTER_ICON_SIZE_CLASS } from "@bb/shared-ui/coarse-pointer-sizing";
+import {
+  COARSE_POINTER_COMPACT_ROW_HEIGHT_CLASS,
+  COARSE_POINTER_ICON_SIZE_CLASS,
+  COARSE_POINTER_ROW_ACTION_SIZE_CLASS,
+} from "@bb/shared-ui/coarse-pointer-sizing";
+import { CHROME_SECTION_LABEL_CLASS } from "@bb/shared-ui/chrome-style-tokens";
 import { useIsCompactViewport } from "@bb/shared-ui/hooks/use-compact-viewport";
+import {
+  Popover,
+  PopoverContent,
+  PopoverTrigger,
+} from "@bb/shared-ui/popover";
 import { PluginIcon } from "@/components/plugin/PluginIcon";
 import { PluginSlotMount } from "@/components/plugin/PluginSlotMount";
 import { PROJECT_LIST_ACTION_BUTTON_CLASS } from "@/components/sidebar/ProjectList";
-import { getPluginPanelRoutePath } from "@/lib/route-paths";
+import {
+  AUTOMATIONS_PLUGIN_ID,
+  getPluginPanelRoutePath,
+} from "@/lib/route-paths";
 import {
   usePluginNavPanelChrome,
   type PluginNavPanelChrome,
+  type PluginNavPanelChromeEntry,
 } from "@/lib/plugin-nav-panel-chrome";
 import { cn } from "@bb/shared-ui/lib/utils";
 import type { PluginNavPanelSlot } from "@/lib/plugin-slots";
-import { usePaneContentSplitDrag } from "@/components/sidebar/usePaneContentSplitDrag";
+import {
+  usePaneContentSplitActions,
+  usePaneContentSplitDrag,
+} from "@/components/sidebar/usePaneContentSplitDrag";
 import { usePaneContentSplitIndicator } from "@/components/sidebar/paneContentSplitIndicator";
 import type { MiniMapSlot } from "@/components/sidebar/paneContentSplitIndicator";
 import { SplitPaneMiniMap } from "@/components/sidebar/SplitPaneMiniMap";
@@ -56,109 +78,223 @@ import { useSidebarSortable } from "@/components/sidebar/sortableMotion";
 import { useSidebarReorderDnd } from "@/components/sidebar/useSidebarReorderDnd";
 import type { SidebarSortableDragBindings } from "@/components/sidebar/sortableMotion";
 import {
-  hiddenPluginNavPanelsAtom,
   pluginNavPanelOrderAtom,
+  pluginNavVisiblePanelKeysAtom,
 } from "./pluginNavSidebarAtoms";
 import {
-  arrangePluginNavPanels,
+  arrangePluginNavPanelPreferences,
+  BUILT_IN_SIDEBAR_NAVIGATION_KEYS,
   getPluginNavPanelKey,
-  hidePluginNavPanel,
-  seedLeadingNavPanelKeys,
-  showPluginNavPanel,
+  togglePluginNavPanelVisibility,
 } from "./pluginNavSidebarOrder";
 import { haveSameOrder, reorderStoredOrder } from "@/lib/stored-order";
 
-const BUILTIN_NAV_ROW_PLUGIN_ID = "__builtin__";
+const PLUGIN_NAV_VISIBLE_LIMIT = 3;
 
-const TOOLS_NAV_ROW_KEY = getPluginNavPanelKey({
-  pluginId: BUILTIN_NAV_ROW_PLUGIN_ID,
-  id: "tools",
-});
+type PluginSidebarNavRow = {
+  kind: "plugin";
+  pluginId: string;
+  id: string;
+  title: string;
+  chrome: PluginNavPanelChrome;
+  panel: PluginNavPanelSlot | null;
+};
 
-type SidebarNavRow =
-  | {
-      kind: "tools";
-      pluginId: string;
-      id: string;
-      title: string;
-      routePath: string;
-    }
-  | {
-      kind: "plugin";
-      pluginId: string;
-      id: string;
-      title: string;
-      chrome: PluginNavPanelChrome;
-      panel: PluginNavPanelSlot | null;
-    };
-
-export function PluginNavSidebarItems({
-  toolsRoutePath,
-  ...props
-}: {
+export interface BuiltInSidebarNavEntry {
+  kind: "built-in";
+  pluginId: "__bb__";
+  id: string;
+  title: string;
+  icon: ReactNode;
+  content: ReactNode;
+  disabled?: boolean;
+  onActivate: (event: ReactMouseEvent<HTMLButtonElement>) => void;
+}
+
+type SidebarNavRow = PluginSidebarNavRow | BuiltInSidebarNavEntry;
+
+function isPluginSidebarNavRow(
+  row: SidebarNavRow,
+): row is PluginSidebarNavRow {
+  return row.kind === "plugin";
+}
+
+export function PluginNavSidebarItems(props: {
+  builtInEntries?: readonly BuiltInSidebarNavEntry[];
+  compactCustomizeMode?: boolean;
+  entries?: readonly PluginNavPanelChromeEntry[];
+  leadingOrderKeys?: readonly string[];
+  onCompactCustomizeModeChange?: (isCustomizing: boolean) => void;
   onNavigate?: () => void;
   splitEnabled?: boolean;
-  toolsRoutePath?: string;
 }) {
-  const navPanels = usePluginNavPanelChrome();
-  const rows = useMemo<SidebarNavRow[]>(() => {
-    const pluginRows = navPanels.map<SidebarNavRow>(({ chrome, panel }) => ({
-      kind: "plugin",
-      pluginId: chrome.pluginId,
-      id: chrome.id,
-      title: chrome.title,
-      chrome,
-      panel,
-    }));
-    if (toolsRoutePath === undefined) return pluginRows;
-    return [
-      {
-        kind: "tools",
-        pluginId: BUILTIN_NAV_ROW_PLUGIN_ID,
-        id: "tools",
-        title: "Extensions",
-        routePath: toolsRoutePath,
-      },
-      ...pluginRows,
-    ];
-  }, [navPanels, toolsRoutePath]);
+  const discoveredEntries = usePluginNavPanelChrome();
+  const entries = props.entries ?? discoveredEntries;
+  const rows = useMemo<SidebarNavRow[]>(
+    () => [
+      ...(props.builtInEntries ?? []),
+      ...entries.map(({ chrome, panel }) => ({
+        kind: "plugin" as const,
+        pluginId:
+          chrome.pluginId === AUTOMATIONS_PLUGIN_ID
+            ? "__bb__"
+            : chrome.pluginId,
+        id:
+          chrome.pluginId === AUTOMATIONS_PLUGIN_ID
+            ? "automations"
+            : chrome.id,
+        title: chrome.title,
+        chrome,
+        panel,
+      })),
+    ],
+    [entries, props.builtInEntries],
+  );
+  const leadingOrderKeys = useMemo(
+    () =>
+      props.leadingOrderKeys ??
+      (props.builtInEntries ?? []).map(getPluginNavPanelKey),
+    [props.builtInEntries, props.leadingOrderKeys],
+  );
   if (rows.length === 0) return null;
-  return <PluginNavSidebarItemList {...props} rows={rows} />;
+  return (
+    <PluginNavSidebarItemList
+      rows={rows}
+      leadingOrderKeys={leadingOrderKeys}
+      splitEnabled={props.splitEnabled ?? false}
+      {...(props.compactCustomizeMode === undefined
+        ? {}
+        : { compactCustomizeMode: props.compactCustomizeMode })}
+      {...(props.onCompactCustomizeModeChange
+        ? {
+            onCompactCustomizeModeChange:
+              props.onCompactCustomizeModeChange,
+          }
+        : {})}
+      {...(props.onNavigate ? { onNavigate: props.onNavigate } : {})}
+    />
+  );
 }
 
 function PluginNavSidebarItemList({
+  compactCustomizeMode,
+  leadingOrderKeys,
+  onCompactCustomizeModeChange,
   onNavigate,
   rows,
   splitEnabled = false,
 }: {
+  compactCustomizeMode?: boolean;
+  leadingOrderKeys: readonly string[];
+  onCompactCustomizeModeChange?: (isCustomizing: boolean) => void;
   onNavigate?: () => void;
   rows: readonly SidebarNavRow[];
   splitEnabled?: boolean;
 }) {
   const location = useLocation();
+  const navigate = useNavigate();
+  const isCompactViewport = useIsCompactViewport();
+  const splitActions = usePaneContentSplitActions();
   const [storedOrder, setStoredOrder] = useAtom(pluginNavPanelOrderAtom);
-  const [hiddenKeys, setHiddenKeys] = useAtom(hiddenPluginNavPanelsAtom);
-  const [isOverflowOpen, setIsOverflowOpen] = useState(false);
-
-  const { visible, hidden, normalizedOrder } = useMemo(() => {
-    const leadingKeys = rows.some((row) => row.kind === "tools")
-      ? [TOOLS_NAV_ROW_KEY]
-      : [];
-    return arrangePluginNavPanels({
-      panels: rows,
-      storedOrder: seedLeadingNavPanelKeys(storedOrder, leadingKeys),
-      hiddenKeys,
-    });
-  }, [hiddenKeys, rows, storedOrder]);
+  const [storedVisibleKeys, setStoredVisibleKeys] = useAtom(
+    pluginNavVisiblePanelKeysAtom,
+  );
+  const [uncontrolledCustomizeOpen, setUncontrolledCustomizeOpen] =
+    useState(false);
+  const containerRef = useRef<HTMLDivElement>(null);
+  const restoreCustomizeTriggerFocusRef = useRef(false);
+  const isCustomizeOpen =
+    isCompactViewport && compactCustomizeMode !== undefined
+      ? compactCustomizeMode
+      : uncontrolledCustomizeOpen;
+  const setIsCustomizeOpen = useCallback(
+    (isOpen: boolean) => {
+      if (!isCompactViewport || compactCustomizeMode === undefined) {
+        setUncontrolledCustomizeOpen(isOpen);
+      }
+      if (isCompactViewport) {
+        onCompactCustomizeModeChange?.(isOpen);
+      }
+    },
+    [
+      compactCustomizeMode,
+      isCompactViewport,
+      onCompactCustomizeModeChange,
+    ],
+  );
+  const defaultVisibleKeys = useMemo(
+    () =>
+      leadingOrderKeys.filter((key) =>
+        rows.some((row) => getPluginNavPanelKey(row) === key),
+      ),
+    [leadingOrderKeys, rows],
+  );
+  const newLeadingKeys = useMemo(
+    () => leadingOrderKeys.filter((key) => !storedOrder.includes(key)),
+    [leadingOrderKeys, storedOrder],
+  );
+  const {
+    ordered,
+    normalizedOrder,
+    normalizedVisibleKeys,
+    visible,
+    visibleKeys,
+  } = useMemo(
+    () =>
+      arrangePluginNavPanelPreferences({
+        panels: rows,
+        storedOrder:
+          newLeadingKeys.length === 0
+            ? storedOrder
+            : [...newLeadingKeys, ...storedOrder],
+        storedVisibleKeys:
+          storedVisibleKeys === null || newLeadingKeys.length === 0
+            ? storedVisibleKeys
+            : [...newLeadingKeys, ...storedVisibleKeys],
+        defaultVisibleKeys,
+        defaultVisibleCount: PLUGIN_NAV_VISIBLE_LIMIT,
+      }),
+    [
+      defaultVisibleKeys,
+      newLeadingKeys,
+      rows,
+      storedOrder,
+      storedVisibleKeys,
+    ],
+  );
 
   useEffect(() => {
     if (haveSameOrder(storedOrder, normalizedOrder)) return;
     setStoredOrder(normalizedOrder);
   }, [normalizedOrder, setStoredOrder, storedOrder]);
 
-  const visibleKeys = useMemo(
-    () => visible.map(getPluginNavPanelKey),
-    [visible],
+  useEffect(() => {
+    if (
+      storedVisibleKeys === null ||
+      normalizedVisibleKeys === null ||
+      haveSameOrder(storedVisibleKeys, normalizedVisibleKeys)
+    ) {
+      return;
+    }
+    setStoredVisibleKeys(normalizedVisibleKeys);
+  }, [normalizedVisibleKeys, setStoredVisibleKeys, storedVisibleKeys]);
+
+  const orderedKeys = useMemo(
+    () => ordered.map(getPluginNavPanelKey),
+    [ordered],
+  );
+
+  const setPanelVisible = useCallback(
+    (key: string, isVisible: boolean) => {
+      setStoredVisibleKeys(
+        togglePluginNavPanelVisibility(
+          normalizedVisibleKeys ?? visibleKeys,
+          key,
+          isVisible,
+        ),
+      );
+    },
+    [normalizedVisibleKeys, setStoredVisibleKeys, visibleKeys],
   );
 
   const handleDragEnd = useCallback(
@@ -184,104 +320,507 @@ function PluginNavSidebarItemList({
     onDragEnd: handleDragEnd,
   });
 
-  const handleHide = useCallback(
-    (key: string) => {
-      setHiddenKeys((current) => hidePluginNavPanel(current, key));
-    },
-    [setHiddenKeys],
-  );
-  const handleShow = useCallback(
-    (key: string) => {
-      setHiddenKeys((current) => showPluginNavPanel(current, key));
+  const handleCustomizeDragEnd = useCallback(
+    (activeKey: string, overKey: string) => {
+      const nextOrder = reorderStoredOrder({
+        activeId: activeKey,
+        overId: overKey,
+        order: normalizedOrder,
+        visibleIds: orderedKeys,
+      });
+      if (!nextOrder) return;
+      if (storedVisibleKeys === null) setStoredVisibleKeys(visibleKeys);
+      setStoredOrder(nextOrder);
     },
-    [setHiddenKeys],
+    [
+      normalizedOrder,
+      orderedKeys,
+      setStoredOrder,
+      setStoredVisibleKeys,
+      storedVisibleKeys,
+      visibleKeys,
+    ],
   );
 
-  const reorderDisabled = visible.length < 2;
+  const reorderDisabled = ordered.length < 2;
   const rowProps = {
     onNavigate,
     pathname: location.pathname,
     splitEnabled,
+    onHide: (key: string) => setPanelVisible(key, false),
   };
 
+  const handleActivate = useCallback(
+    (row: SidebarNavRow, event: ReactMouseEvent<HTMLButtonElement>) => {
+      if (!isPluginSidebarNavRow(row)) {
+        row.onActivate(event);
+        return;
+      }
+      if (event.metaKey || event.ctrlKey) {
+        splitActions.openInSplit({
+          content: {
+            kind: "plugin-panel",
+            pluginId: row.chrome.pluginId,
+            panelPath: row.chrome.path,
+            subPath: "",
+          },
+          enabled: splitEnabled,
+          label: row.title,
+          onNavigate,
+        });
+        return;
+      }
+      onNavigate?.();
+      void navigate(
+        getPluginPanelRoutePath({
+          pluginId: row.chrome.pluginId,
+          path: row.chrome.path,
+        }),
+      );
+    },
+    [navigate, onNavigate, splitActions, splitEnabled],
+  );
+
+  useEffect(() => {
+    if (isCustomizeOpen || !restoreCustomizeTriggerFocusRef.current) return;
+    restoreCustomizeTriggerFocusRef.current = false;
+    containerRef.current
+      ?.querySelector<HTMLElement>(
+        '[data-testid="sidebar-navigation-customize-trigger"]',
+      )
+      ?.focus();
+  }, [isCustomizeOpen]);
+
+  if (isCompactViewport && isCustomizeOpen) {
+    return (
+      <div
+        ref={containerRef}
+        className="flex min-h-0 flex-1 flex-col px-2 py-2 group-data-[collapsible=icon]:hidden"
+        data-testid="plugin-nav-sidebar-items"
+        data-sidebar-navigation-customize-mode="true"
+      >
+        <SidebarNavigationInlineCustomizeMode
+          rows={ordered}
+          visibleKeys={visibleKeys}
+          onActivate={handleActivate}
+          onBack={() => {
+            restoreCustomizeTriggerFocusRef.current = true;
+            setIsCustomizeOpen(false);
+          }}
+          onExit={() => setIsCustomizeOpen(false)}
+          onDragEnd={handleCustomizeDragEnd}
+          onVisibleChange={setPanelVisible}
+        />
+      </div>
+    );
+  }
+
   return (
     <div
-      className="-mt-1.5 shrink-0 space-y-0.5 px-2 pb-2 group-data-[collapsible=icon]:hidden"
+      ref={containerRef}
+      className="shrink-0 space-y-0.5 px-2 py-2 group-data-[collapsible=icon]:hidden"
       data-testid="plugin-nav-sidebar-items"
       onClickCapture={onClickCapture}
     >
+      {!visibleKeys.includes(BUILT_IN_SIDEBAR_NAVIGATION_KEYS.newThread) ? (
+        <div className="flex min-w-0 items-center justify-end">
+          <SidebarNavigationCustomizeMenu
+            isOpen={isCustomizeOpen}
+            rows={ordered}
+            visibleKeys={visibleKeys}
+            onActivate={handleActivate}
+            onDragEnd={handleCustomizeDragEnd}
+            onOpenChange={setIsCustomizeOpen}
+            onVisibleChange={setPanelVisible}
+          />
+        </div>
+      ) : null}
       <DndContext {...dndContextProps}>
         <SortableContext
           items={visibleKeys}
           strategy={verticalListSortingStrategy}
         >
-          {visible.map((row) => (
-            <SortableSidebarNavRow
-              key={getPluginNavPanelKey(row)}
-              row={row}
-              reorderDisabled={reorderDisabled}
-              onHide={handleHide}
-              {...rowProps}
-            />
-          ))}
+          {visible.map((row) =>
+            isPluginSidebarNavRow(row) ? (
+              <SortableSidebarNavRow
+                key={getPluginNavPanelKey(row)}
+                row={row}
+                reorderDisabled={reorderDisabled}
+                {...rowProps}
+              />
+            ) : (
+              <div
+                key={getPluginNavPanelKey(row)}
+                data-sidebar-navigation-item={getPluginNavPanelKey(row)}
+              >
+                {getPluginNavPanelKey(row) ===
+                BUILT_IN_SIDEBAR_NAVIGATION_KEYS.newThread ? (
+                  <div
+                    className="flex min-w-0 items-center gap-0.5"
+                    data-sidebar-navigation-primary-row
+                  >
+                    <div className="min-w-0 flex-1">{row.content}</div>
+                    <SidebarNavigationCustomizeMenu
+                      isOpen={isCustomizeOpen}
+                      rows={ordered}
+                      visibleKeys={visibleKeys}
+                      onActivate={handleActivate}
+                      onDragEnd={handleCustomizeDragEnd}
+                      onOpenChange={setIsCustomizeOpen}
+                      onVisibleChange={setPanelVisible}
+                    />
+                  </div>
+                ) : (
+                  row.content
+                )}
+              </div>
+            ),
+          )}
         </SortableContext>
       </DndContext>
-      {hidden.length > 0 ? (
-        <>
-          <PluginNavSidebarOverflowToggle
-            count={hidden.length}
-            isOpen={isOverflowOpen}
-            onToggle={() => setIsOverflowOpen((open) => !open)}
-          />
-          {isOverflowOpen
-            ? hidden.map((row) => (
-                <SidebarNavRowItem
-                  key={getPluginNavPanelKey(row)}
-                  row={row}
-                  isHidden
-                  onShow={handleShow}
-                  {...rowProps}
-                />
-              ))
-            : null}
-        </>
-      ) : null}
     </div>
   );
 }
 
-function PluginNavSidebarOverflowToggle({
-  count,
+function SidebarNavigationInlineCustomizeMode({
+  onActivate,
+  onBack,
+  onDragEnd,
+  onExit,
+  onVisibleChange,
+  rows,
+  visibleKeys,
+}: {
+  onActivate: (
+    row: SidebarNavRow,
+    event: ReactMouseEvent<HTMLButtonElement>,
+  ) => void;
+  onBack: () => void;
+  onDragEnd: (activeKey: string, overKey: string) => void;
+  onExit: () => void;
+  onVisibleChange: (key: string, visible: boolean) => void;
+  rows: readonly SidebarNavRow[];
+  visibleKeys: readonly string[];
+}) {
+  const backButtonRef = useRef<HTMLButtonElement>(null);
+
+  useEffect(() => {
+    backButtonRef.current?.focus();
+  }, []);
+
+  return (
+    <div
+      className="flex min-h-0 flex-1 flex-col"
+      data-testid="sidebar-navigation-customize-inline"
+    >
+      <div className="flex shrink-0 items-center gap-1">
+        <Button
+          ref={backButtonRef}
+          type="button"
+          variant="ghost"
+          size="icon"
+          aria-label="Back to sidebar"
+          className={cn(
+            COARSE_POINTER_ROW_ACTION_SIZE_CLASS,
+            "shrink-0 text-muted-foreground ring-sidebar-ring hover:bg-sidebar-accent hover:text-sidebar-foreground focus-visible:ring-2",
+          )}
+          onClick={onBack}
+        >
+          <Icon name="ChevronLeft" aria-hidden="true" />
+        </Button>
+        <div className={cn("min-w-0 flex-1 px-1", CHROME_SECTION_LABEL_CLASS)}>
+          Customize sidebar
+        </div>
+      </div>
+      <div className="min-h-0 flex-1 overflow-y-auto pt-1">
+        <SidebarNavigationCustomizeList
+          rows={rows}
+          visibleKeys={visibleKeys}
+          surface="sidebar"
+          onActivate={(row, event) => {
+            onActivate(row, event);
+            onExit();
+          }}
+          onDragEnd={onDragEnd}
+          onVisibleChange={onVisibleChange}
+        />
+      </div>
+    </div>
+  );
+}
+
+function SidebarNavigationCustomizeMenu({
   isOpen,
-  onToggle,
+  onActivate,
+  onDragEnd,
+  onOpenChange,
+  onVisibleChange,
+  rows,
+  visibleKeys,
 }: {
-  count: number;
   isOpen: boolean;
-  onToggle: () => void;
+  onActivate: (
+    row: SidebarNavRow,
+    event: ReactMouseEvent<HTMLButtonElement>,
+  ) => void;
+  onDragEnd: (activeKey: string, overKey: string) => void;
+  onOpenChange: (isOpen: boolean) => void;
+  onVisibleChange: (key: string, visible: boolean) => void;
+  rows: readonly SidebarNavRow[];
+  visibleKeys: readonly string[];
 }) {
-  return (
+  const isCompactViewport = useIsCompactViewport();
+  const contentRef = useRef<HTMLDivElement>(null);
+  const trigger = (
     <Button
       type="button"
-      size="sm"
       variant="ghost"
-      aria-expanded={isOpen}
+      size="icon"
+      aria-label="Customize sidebar navigation"
+      aria-expanded={isCompactViewport ? isOpen : undefined}
       className={cn(
-        PROJECT_LIST_ACTION_BUTTON_CLASS,
-        "w-full text-subtle-foreground/75",
+        COARSE_POINTER_ROW_ACTION_SIZE_CLASS,
+        "shrink-0 text-subtle-foreground opacity-60 ring-sidebar-ring hover:bg-sidebar-accent hover:text-sidebar-foreground hover:opacity-100 focus-visible:ring-2 focus-visible:opacity-100 max-md:pointer-coarse:[&_svg]:size-5 data-[state=open]:bg-sidebar-accent data-[state=open]:text-sidebar-foreground data-[state=open]:opacity-100",
       )}
-      onClick={onToggle}
-      data-testid="plugin-nav-sidebar-overflow-toggle"
+      data-testid="sidebar-navigation-customize-trigger"
+      {...(isCompactViewport
+        ? { onClick: () => onOpenChange(true) }
+        : {})}
     >
-      <Icon
-        name="ChevronRight"
+      <HugeiconsIcon icon={FilterHorizontalIcon} aria-hidden="true" />
+    </Button>
+  );
+
+  if (isCompactViewport) {
+    return <span className="inline-flex shrink-0">{trigger}</span>;
+  }
+
+  return (
+    <Popover open={isOpen} onOpenChange={onOpenChange}>
+      <span className="inline-flex shrink-0">
+        <PopoverTrigger asChild>{trigger}</PopoverTrigger>
+      </span>
+      <PopoverContent
+        ref={contentRef}
+        side="right"
+        align="start"
+        sideOffset={8}
+        className="w-52 p-2"
+        onOpenAutoFocus={(event) => {
+          event.preventDefault();
+          contentRef.current
+            ?.querySelector<HTMLElement>(
+              "[data-sidebar-navigation-customize-launch]",
+            )
+            ?.focus();
+        }}
+      >
+        <div className={cn("px-2 py-1", CHROME_SECTION_LABEL_CLASS)}>
+          Customize sidebar
+        </div>
+        <SidebarNavigationCustomizeList
+          rows={rows}
+          visibleKeys={visibleKeys}
+          onActivate={(row, event) => {
+            onActivate(row, event);
+            onOpenChange(false);
+          }}
+          onDragEnd={onDragEnd}
+          onVisibleChange={onVisibleChange}
+        />
+      </PopoverContent>
+    </Popover>
+  );
+}
+
+function SidebarNavigationCustomizeList({
+  onActivate,
+  onDragEnd,
+  onVisibleChange,
+  rows,
+  surface = "popover",
+  visibleKeys,
+}: {
+  onActivate: (
+    row: SidebarNavRow,
+    event: ReactMouseEvent<HTMLButtonElement>,
+  ) => void;
+  onDragEnd: (activeKey: string, overKey: string) => void;
+  onVisibleChange: (key: string, visible: boolean) => void;
+  rows: readonly SidebarNavRow[];
+  surface?: "popover" | "sidebar";
+  visibleKeys: readonly string[];
+}) {
+  const orderedKeys = useMemo(
+    () => rows.map(getPluginNavPanelKey),
+    [rows],
+  );
+  const visibleKeySet = useMemo(() => new Set(visibleKeys), [visibleKeys]);
+  const handleDragEnd = useCallback(
+    (event: DragEndEvent) => {
+      if (
+        typeof event.active.id !== "string" ||
+        typeof event.over?.id !== "string"
+      ) {
+        return;
+      }
+      onDragEnd(event.active.id, event.over.id);
+    },
+    [onDragEnd],
+  );
+  const { dndContextProps, onClickCapture } = useSidebarReorderDnd({
+    onDragEnd: handleDragEnd,
+  });
+
+  return (
+    <div
+      role="list"
+      aria-label="Sidebar navigation"
+      className="space-y-0.5"
+      onClickCapture={onClickCapture}
+    >
+      <DndContext {...dndContextProps}>
+        <SortableContext
+          items={orderedKeys}
+          strategy={verticalListSortingStrategy}
+        >
+          {rows.map((row) => {
+            const key = getPluginNavPanelKey(row);
+            return (
+              <SortableSidebarNavigationCustomizeItem
+                key={key}
+                row={row}
+                checked={visibleKeySet.has(key)}
+                reorderDisabled={rows.length < 2}
+                surface={surface}
+                onActivate={(event) => onActivate(row, event)}
+                onCheckedChange={(checked) =>
+                  onVisibleChange(key, checked)
+                }
+              />
+            );
+          })}
+        </SortableContext>
+      </DndContext>
+    </div>
+  );
+}
+
+function SortableSidebarNavigationCustomizeItem({
+  checked,
+  onActivate,
+  onCheckedChange,
+  reorderDisabled,
+  row,
+  surface,
+}: {
+  checked: boolean;
+  onActivate: (event: ReactMouseEvent<HTMLButtonElement>) => void;
+  onCheckedChange: (checked: boolean) => void;
+  reorderDisabled: boolean;
+  row: SidebarNavRow;
+  surface: "popover" | "sidebar";
+}) {
+  const panelKey = getPluginNavPanelKey(row);
+  const checkboxId = useId();
+  const { dragBindings, setNodeRef, style } = useSidebarSortable({
+    id: panelKey,
+    disabled: reorderDisabled,
+  });
+  const icon = isPluginSidebarNavRow(row) ? (
+    <PluginIcon pluginId={row.chrome.pluginId} icon={row.chrome.icon} />
+  ) : (
+    row.icon
+  );
+
+  return (
+    <div
+      ref={setNodeRef}
+      style={style}
+      role="listitem"
+      className={cn(
+        "group flex min-h-7 items-center rounded-md px-1 text-xs",
+        surface === "sidebar"
+          ? cn(
+              COARSE_POINTER_COMPACT_ROW_HEIGHT_CLASS,
+              "text-sidebar-foreground hover:bg-sidebar-accent focus-within:bg-sidebar-accent",
+            )
+          : "text-popover-foreground hover:bg-state-hover focus-within:bg-state-hover",
+      )}
+      data-plugin-nav-customize-item={panelKey}
+    >
+      <button
+        type="button"
+        ref={dragBindings.setActivatorNodeRef}
+        {...dragBindings.attributes}
+        {...dragBindings.listeners}
+        aria-label={`Reorder ${row.title}`}
         className={cn(
-          "size-3 shrink-0 transition-transform duration-150",
-          isOpen && "rotate-90",
+          "flex size-6 shrink-0 cursor-grab touch-none items-center justify-center rounded-sm text-subtle-foreground/60 focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring active:cursor-grabbing",
+          surface === "sidebar"
+            ? cn(
+                COARSE_POINTER_ROW_ACTION_SIZE_CLASS,
+                "hover:text-sidebar-foreground focus-visible:text-sidebar-foreground",
+              )
+            : "hover:text-popover-foreground focus-visible:text-popover-foreground",
         )}
-        aria-hidden="true"
-      />
-      <span className="min-w-0 truncate text-left">{`More (${count})`}</span>
-    </Button>
+        onClick={(event) => event.stopPropagation()}
+        data-plugin-nav-customize-drag-handle={panelKey}
+      >
+        <Icon
+          name="DragDropVertical"
+          className={COARSE_POINTER_ICON_SIZE_CLASS}
+        />
+      </button>
+      <button
+        type="button"
+        disabled={!isPluginSidebarNavRow(row) && row.disabled}
+        className={cn(
+          "flex min-w-0 flex-1 cursor-pointer items-center gap-2 rounded-sm px-1 text-left outline-none disabled:cursor-default disabled:opacity-50",
+          surface === "sidebar"
+            ? COARSE_POINTER_COMPACT_ROW_HEIGHT_CLASS
+            : "min-h-7",
+        )}
+        onClick={onActivate}
+        data-sidebar-navigation-customize-launch={panelKey}
+      >
+        <span className="flex size-4 shrink-0 items-center justify-center">
+          {icon}
+        </span>
+        <span className="min-w-0 flex-1 truncate">{row.title}</span>
+      </button>
+      {surface === "sidebar" ? (
+        <label
+          htmlFor={checkboxId}
+          className={cn(
+            COARSE_POINTER_ROW_ACTION_SIZE_CLASS,
+            "flex shrink-0 cursor-pointer items-center justify-center",
+          )}
+          onClick={(event) => event.stopPropagation()}
+        >
+          <Checkbox
+            id={checkboxId}
+            checked={checked}
+            aria-label={`Show ${row.title} in sidebar`}
+            onCheckedChange={(nextChecked) =>
+              onCheckedChange(nextChecked === true)
+            }
+            data-plugin-nav-customize-checkbox={panelKey}
+          />
+        </label>
+      ) : (
+        <Checkbox
+          checked={checked}
+          aria-label={`Show ${row.title} in sidebar`}
+          onCheckedChange={(nextChecked) =>
+            onCheckedChange(nextChecked === true)
+          }
+          onClick={(event) => event.stopPropagation()}
+          data-plugin-nav-customize-checkbox={panelKey}
+          className="mx-1"
+        />
+      )}
+    </div>
   );
 }
 
@@ -306,13 +845,11 @@ const SortableSidebarNavRow = function SortableSidebarNavRow({
 };
 
 interface SidebarNavRowItemProps {
-  row: SidebarNavRow;
+  row: PluginSidebarNavRow;
   pathname: string;
   onNavigate?: () => void;
   splitEnabled: boolean;
-  isHidden?: boolean;
   onHide?: (key: string) => void;
-  onShow?: (key: string) => void;
   dragBindings?: SidebarSortableDragBindings;
   rowRef?: (element: HTMLElement | null) => void;
   rowStyle?: CSSProperties;
@@ -323,9 +860,7 @@ function SidebarNavRowItem({
   splitEnabled,
   ...props
 }: SidebarNavRowItemProps) {
-  return row.kind === "tools" ? (
-    <ToolsNavSidebarItem {...props} row={row} />
-  ) : (
+  return (
     <PluginNavSidebarItem {...props} row={row} splitEnabled={splitEnabled} />
   );
 }
@@ -333,18 +868,16 @@ function SidebarNavRowItem({
 type PluginNavRowMenuSurface = "context" | "dropdown";
 
 function PluginNavRowVisibilityMenuItem({
-  isHidden,
   onSelect,
   surface,
 }: {
-  isHidden: boolean;
   onSelect: () => void;
   surface: PluginNavRowMenuSurface;
 }) {
   const content = (
     <>
-      <Icon name={isHidden ? "Eye" : "EyeOff"} aria-hidden="true" />
-      {isHidden ? "Show in sidebar" : "Hide from sidebar"}
+      <Icon name="EyeOff" aria-hidden="true" />
+      Hide from sidebar
     </>
   );
   return surface === "context" ? (
@@ -363,27 +896,28 @@ function ToolsNavSidebarItemIcon() {
   );
 }
 
-function ToolsNavSidebarItem({
-  row,
-  pathname: _pathname,
+export function ExtensionsNavSidebarItem({
+  routePath,
   onNavigate,
-  ...props
-}: Omit<SidebarNavRowItemProps, "row" | "splitEnabled"> & {
-  row: Extract<SidebarNavRow, { kind: "tools" }>;
+}: {
+  routePath: string;
+  onNavigate?: () => void;
 }) {
   const navigate = useNavigate();
   return (
-    <SidebarNavRowChrome
-      {...props}
-      rowKey={getPluginNavPanelKey(row)}
-      title={row.title}
-      icon={<ToolsNavSidebarItemIcon />}
-      isActive={false}
-      onSelect={() => {
+    <Button
+      type="button"
+      size="sm"
+      variant="ghost"
+      className={cn(PROJECT_LIST_ACTION_BUTTON_CLASS, "w-full")}
+      onClick={() => {
         onNavigate?.();
-        void navigate(row.routePath);
+        void navigate(routePath);
       }}
-    />
+    >
+      <ToolsNavSidebarItemIcon />
+      <span className="min-w-0 truncate text-left">Extensions</span>
+    </Button>
   );
 }
 
@@ -393,9 +927,7 @@ function PluginNavSidebarItem({
   onNavigate,
   splitEnabled,
   ...props
-}: Omit<SidebarNavRowItemProps, "row"> & {
-  row: Extract<SidebarNavRow, { kind: "plugin" }>;
-}) {
+}: SidebarNavRowItemProps) {
   const { chrome, panel } = row;
   const navigate = useNavigate();
   const isCompactViewport = useIsCompactViewport();
@@ -409,6 +941,7 @@ function PluginNavSidebarItem({
     panelPath: chrome.path,
     subPath: "",
   } as const;
+  const rowKey = getPluginNavPanelKey(row);
   const { onPointerDown, openInSplit } = usePaneContentSplitDrag({
     content,
     enabled: splitEnabled,
@@ -432,7 +965,7 @@ function PluginNavSidebarItem({
   return (
     <SidebarNavRowChrome
       {...props}
-      rowKey={getPluginNavPanelKey(row)}
+      rowKey={rowKey}
       title={chrome.title}
       icon={<PluginIcon pluginId={chrome.pluginId} icon={chrome.icon} />}
       isActive={pathname === path || pathname.startsWith(`${path}/`)}
@@ -458,11 +991,9 @@ interface SidebarNavRowChromeProps {
   isActive: boolean;
   onSelect: (event: ReactMouseEvent<HTMLButtonElement>) => void;
   onPointerDown?: PointerEventHandler<HTMLElement>;
+  onHide?: (key: string) => void;
   splitMiniMap?: MiniMapSlot[] | null;
   accessory?: ReactNode;
-  isHidden?: boolean;
-  onHide?: (key: string) => void;
-  onShow?: (key: string) => void;
   dragBindings?: SidebarSortableDragBindings;
   rowRef?: (element: HTMLElement | null) => void;
   rowStyle?: CSSProperties;
@@ -475,11 +1006,9 @@ function SidebarNavRowChrome({
   isActive,
   onSelect,
   onPointerDown,
+  onHide,
   splitMiniMap = null,
   accessory,
-  isHidden = false,
-  onHide,
-  onShow,
   dragBindings,
   rowRef,
   rowStyle,
@@ -490,8 +1019,7 @@ function SidebarNavRowChrome({
   const visibilityItem = (surface: PluginNavRowMenuSurface): ReactNode => (
     <PluginNavRowVisibilityMenuItem
       surface={surface}
-      isHidden={isHidden}
-      onSelect={() => (isHidden ? onShow?.(rowKey) : onHide?.(rowKey))}
+      onSelect={() => onHide?.(rowKey)}
     />
   );
 
@@ -502,6 +1030,7 @@ function SidebarNavRowChrome({
           ref={rowRef}
           style={rowStyle}
           className={cn(SIDEBAR_HOVER_ACTIONS_ROW_CLASS, "relative")}
+          data-sidebar-navigation-item={rowKey}
         >
           <Button
             type="button"
@@ -512,7 +1041,6 @@ function SidebarNavRowChrome({
               "w-full pr-7",
               accessory && "pr-18",
               isActive && "bg-sidebar-accent text-sidebar-foreground",
-              isHidden && "text-subtle-foreground",
             )}
             aria-current={isActive ? "page" : undefined}
             ref={dragBindings?.setActivatorNodeRef}
diff --git a/apps/app/src/components/plugin/pluginNavSidebarAtoms.test.ts b/apps/app/src/components/plugin/pluginNavSidebarAtoms.test.ts
new file mode 100644
index 0000000000..e4fe1cb79f
--- /dev/null
+++ b/apps/app/src/components/plugin/pluginNavSidebarAtoms.test.ts
@@ -0,0 +1,178 @@
+// @vitest-environment jsdom
+
+import { createStore } from "jotai";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+afterEach(() => {
+  window.localStorage.clear();
+  vi.resetModules();
+});
+
+describe("pluginNavPanelOrderAtom migration", () => {
+  it("converts legacy hidden keys into positional overflow order", async () => {
+    window.localStorage.setItem(
+      "bb.sidebar.pluginPanelOrder",
+      JSON.stringify(["docs/main", "tasks/main", "github/main"]),
+    );
+    window.localStorage.setItem(
+      "bb.sidebar.hiddenPluginPanels",
+      JSON.stringify(["tasks/main", "docs/main"]),
+    );
+
+    const { pluginNavPanelOrderAtom, pluginNavVisiblePanelKeysAtom } =
+      await import("./pluginNavSidebarAtoms");
+    const store = createStore();
+
+    expect(store.get(pluginNavPanelOrderAtom)).toEqual([
+      "github/main",
+      "docs/main",
+      "tasks/main",
+    ]);
+    expect(store.get(pluginNavVisiblePanelKeysAtom)).toEqual([
+      "github/main",
+    ]);
+    expect(
+      window.localStorage.getItem("bb.sidebar.hiddenPluginPanels"),
+    ).toBeNull();
+  });
+
+  it("migrates visibility when it is read before order", async () => {
+    window.localStorage.setItem(
+      "bb.sidebar.pluginPanelOrder",
+      JSON.stringify(["docs/main", "tasks/main", "github/main"]),
+    );
+    window.localStorage.setItem(
+      "bb.sidebar.hiddenPluginPanels",
+      JSON.stringify(["tasks/main"]),
+    );
+
+    const { pluginNavPanelOrderAtom, pluginNavVisiblePanelKeysAtom } =
+      await import("./pluginNavSidebarAtoms");
+    const store = createStore();
+
+    expect(store.get(pluginNavVisiblePanelKeysAtom)).toEqual([
+      "docs/main",
+      "github/main",
+    ]);
+    expect(store.get(pluginNavPanelOrderAtom)).toEqual([
+      "docs/main",
+      "github/main",
+      "tasks/main",
+    ]);
+  });
+
+  it("migrates hidden Automations into the unified visibility preference", async () => {
+    window.localStorage.setItem(
+      "bb.sidebar.pluginPanelOrder",
+      JSON.stringify(["docs/main"]),
+    );
+    window.localStorage.setItem(
+      "bb.sidebar.hiddenPluginPanels",
+      JSON.stringify(["docs/main", "automations/main"]),
+    );
+
+    const { pluginNavPanelOrderAtom, pluginNavVisiblePanelKeysAtom } =
+      await import("./pluginNavSidebarAtoms");
+    const store = createStore();
+
+    expect(store.get(pluginNavPanelOrderAtom)).toEqual([
+      "docs/main",
+      "__bb__/automations",
+    ]);
+    expect(store.get(pluginNavVisiblePanelKeysAtom)).toEqual([]);
+    expect(
+      window.localStorage.getItem("bb.sidebar.hiddenPluginPanels"),
+    ).toBeNull();
+  });
+
+  it("maps legacy built-in order and visibility keys to unified keys", async () => {
+    window.localStorage.setItem(
+      "bb.sidebar.pluginPanelOrder",
+      JSON.stringify(["__builtin__/tools", "automations/main", "docs/main"]),
+    );
+    window.localStorage.setItem(
+      "bb.sidebar.visiblePluginPanels",
+      JSON.stringify(["automations/main", "__builtin__/tools"]),
+    );
+
+    const { pluginNavPanelOrderAtom, pluginNavVisiblePanelKeysAtom } =
+      await import("./pluginNavSidebarAtoms");
+    const store = createStore();
+
+    expect(store.get(pluginNavPanelOrderAtom)).toEqual([
+      "__bb__/extensions",
+      "__bb__/automations",
+      "docs/main",
+    ]);
+    expect(store.get(pluginNavVisiblePanelKeysAtom)).toEqual([
+      "__bb__/automations",
+      "__bb__/extensions",
+    ]);
+  });
+
+  it("keeps fresh visibility unset so defaults can follow available rows", async () => {
+    const { pluginNavPanelOrderAtom, pluginNavVisiblePanelKeysAtom } =
+      await import("./pluginNavSidebarAtoms");
+    const store = createStore();
+
+    expect(store.get(pluginNavPanelOrderAtom)).toEqual([]);
+    expect(store.get(pluginNavVisiblePanelKeysAtom)).toBeNull();
+  });
+
+  it("does not overwrite an existing visibility preference during migration", async () => {
+    window.localStorage.setItem(
+      "bb.sidebar.pluginPanelOrder",
+      JSON.stringify(["docs/main", "tasks/main", "github/main"]),
+    );
+    window.localStorage.setItem(
+      "bb.sidebar.visiblePluginPanels",
+      JSON.stringify(["tasks/main"]),
+    );
+    window.localStorage.setItem(
+      "bb.sidebar.hiddenPluginPanels",
+      JSON.stringify(["docs/main"]),
+    );
+
+    const { pluginNavPanelOrderAtom, pluginNavVisiblePanelKeysAtom } =
+      await import("./pluginNavSidebarAtoms");
+    const store = createStore();
+
+    expect(store.get(pluginNavPanelOrderAtom)).toEqual([
+      "tasks/main",
+      "github/main",
+      "docs/main",
+    ]);
+    expect(store.get(pluginNavVisiblePanelKeysAtom)).toEqual(["tasks/main"]);
+  });
+
+  it("persists an explicit empty visible list", async () => {
+    const { pluginNavVisiblePanelKeysAtom } = await import(
+      "./pluginNavSidebarAtoms"
+    );
+    const store = createStore();
+
+    store.set(pluginNavVisiblePanelKeysAtom, []);
+
+    expect(store.get(pluginNavVisiblePanelKeysAtom)).toEqual([]);
+    expect(
+      window.localStorage.getItem("bb.sidebar.visiblePluginPanels"),
+    ).toBe("[]");
+  });
+
+  it("normalizes persisted visible keys without discarding unregistered keys", async () => {
+    window.localStorage.setItem(
+      "bb.sidebar.visiblePluginPanels",
+      JSON.stringify(["docs/main", "future/main", "docs/main"]),
+    );
+
+    const { pluginNavVisiblePanelKeysAtom } = await import(
+      "./pluginNavSidebarAtoms"
+    );
+    const store = createStore();
+
+    expect(store.get(pluginNavVisiblePanelKeysAtom)).toEqual([
+      "docs/main",
+      "future/main",
+    ]);
+  });
+});
diff --git a/apps/app/src/components/plugin/pluginNavSidebarAtoms.ts b/apps/app/src/components/plugin/pluginNavSidebarAtoms.ts
index 036f1f9a41..63657d2167 100644
--- a/apps/app/src/components/plugin/pluginNavSidebarAtoms.ts
+++ b/apps/app/src/components/plugin/pluginNavSidebarAtoms.ts
@@ -1,19 +1,148 @@
 import { atomWithStorage } from "jotai/utils";
-import { createJsonLocalStorage } from "@/lib/browser-storage";
+import {
+  createJsonLocalStorage,
+  type SyncStorage,
+} from "@/lib/browser-storage";
+import { AUTOMATIONS_PLUGIN_ID } from "@/lib/route-paths";
+import {
+  BUILT_IN_SIDEBAR_NAVIGATION_KEYS,
+  migrateLegacyHiddenPluginNavPanelOrder,
+} from "./pluginNavSidebarOrder";
 
 const PLUGIN_NAV_PANEL_ORDER_STORAGE_KEY = "bb.sidebar.pluginPanelOrder";
+const VISIBLE_PLUGIN_NAV_PANELS_STORAGE_KEY =
+  "bb.sidebar.visiblePluginPanels";
 const HIDDEN_PLUGIN_NAV_PANELS_STORAGE_KEY = "bb.sidebar.hiddenPluginPanels";
+const LEGACY_EXTENSIONS_NAV_PANEL_KEY = "__builtin__/tools";
+
+function toSidebarNavigationKey(key: string): string {
+  if (key === LEGACY_EXTENSIONS_NAV_PANEL_KEY) {
+    return BUILT_IN_SIDEBAR_NAVIGATION_KEYS.extensions;
+  }
+  if (key.startsWith(`${AUTOMATIONS_PLUGIN_ID}/`)) {
+    return BUILT_IN_SIDEBAR_NAVIGATION_KEYS.automations;
+  }
+  return key;
+}
+
+function normalizeStringArray(value: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+  return [
+    ...new Set(
+      value.filter((item): item is string => typeof item === "string"),
+    ),
+  ];
+}
+
+function normalizeSidebarNavigationKeys(value: unknown): string[] {
+  return [...new Set(normalizeStringArray(value).map(toSidebarNavigationKey))];
+}
+
+function normalizeVisiblePanelKeys(value: unknown): string[] | null {
+  return Array.isArray(value) ? normalizeSidebarNavigationKeys(value) : null;
+}
+
+function migrateLegacyPluginNavPreferences(
+  storage: SyncStorage<unknown>,
+  order: readonly string[],
+): string[] {
+  const normalizedOrder = normalizeSidebarNavigationKeys(order);
+  const legacyHiddenValue = storage.getItem(
+    HIDDEN_PLUGIN_NAV_PANELS_STORAGE_KEY,
+    null,
+  );
+  const legacyHidden = normalizeSidebarNavigationKeys(
+    legacyHiddenValue,
+  );
+  const migrated = migrateLegacyHiddenPluginNavPanelOrder(
+    normalizedOrder,
+    legacyHidden,
+  );
+  const storedVisibleKeys = normalizeVisiblePanelKeys(
+    storage.getItem(VISIBLE_PLUGIN_NAV_PANELS_STORAGE_KEY, null),
+  );
+  if (storedVisibleKeys === null && Array.isArray(legacyHiddenValue)) {
+    const hidden = new Set(legacyHidden);
+    storage.setItem(
+      VISIBLE_PLUGIN_NAV_PANELS_STORAGE_KEY,
+      migrated.filter((key) => !hidden.has(key)),
+    );
+  }
+  storage.setItem(PLUGIN_NAV_PANEL_ORDER_STORAGE_KEY, migrated);
+  storage.removeItem(HIDDEN_PLUGIN_NAV_PANELS_STORAGE_KEY);
+  return migrated;
+}
+
+function createPluginNavPanelOrderStorage(): SyncStorage<string[]> {
+  const storage = createJsonLocalStorage<unknown>();
+  return {
+    getItem(key, initialValue) {
+      const order = normalizeSidebarNavigationKeys(
+        storage.getItem(key, initialValue),
+      );
+      return migrateLegacyPluginNavPreferences(storage, order);
+    },
+    setItem(key, value) {
+      storage.setItem(key, normalizeSidebarNavigationKeys(value));
+    },
+    removeItem(key) {
+      storage.removeItem(key);
+    },
+    subscribe: (key, callback, initialValue) =>
+      storage.subscribe?.(
+        key,
+        (value) => callback(normalizeSidebarNavigationKeys(value)),
+        initialValue,
+      ),
+  };
+}
+
+function createPluginNavVisiblePanelKeysStorage(): SyncStorage<
+  string[] | null
+> {
+  const storage = createJsonLocalStorage<unknown>();
+  return {
+    getItem(key, initialValue) {
+      const storedVisibleKeys = normalizeVisiblePanelKeys(
+        storage.getItem(key, initialValue),
+      );
+      if (storedVisibleKeys !== null) return storedVisibleKeys;
+
+      const order = normalizeSidebarNavigationKeys(
+        storage.getItem(PLUGIN_NAV_PANEL_ORDER_STORAGE_KEY, []),
+      );
+      migrateLegacyPluginNavPreferences(storage, order);
+      return normalizeVisiblePanelKeys(storage.getItem(key, initialValue));
+    },
+    setItem(key, value) {
+      if (value === null) {
+        storage.removeItem(key);
+        return;
+      }
+      storage.setItem(key, normalizeSidebarNavigationKeys(value));
+    },
+    removeItem(key) {
+      storage.removeItem(key);
+    },
+    subscribe: (key, callback, initialValue) =>
+      storage.subscribe?.(
+        key,
+        (value) => callback(normalizeVisiblePanelKeys(value)),
+        initialValue,
+      ),
+  };
+}
 
 export const pluginNavPanelOrderAtom = atomWithStorage<string[]>(
   PLUGIN_NAV_PANEL_ORDER_STORAGE_KEY,
   [],
-  createJsonLocalStorage<string[]>(),
+  createPluginNavPanelOrderStorage(),
   { getOnInit: true },
 );
 
-export const hiddenPluginNavPanelsAtom = atomWithStorage<string[]>(
-  HIDDEN_PLUGIN_NAV_PANELS_STORAGE_KEY,
-  [],
-  createJsonLocalStorage<string[]>(),
+export const pluginNavVisiblePanelKeysAtom = atomWithStorage<string[] | null>(
+  VISIBLE_PLUGIN_NAV_PANELS_STORAGE_KEY,
+  null,
+  createPluginNavVisiblePanelKeysStorage(),
   { getOnInit: true },
 );
diff --git a/apps/app/src/components/plugin/pluginNavSidebarOrder.test.ts b/apps/app/src/components/plugin/pluginNavSidebarOrder.test.ts
index 81ebbeced1..35e3f9403e 100644
--- a/apps/app/src/components/plugin/pluginNavSidebarOrder.test.ts
+++ b/apps/app/src/components/plugin/pluginNavSidebarOrder.test.ts
@@ -1,8 +1,10 @@
 import { describe, expect, it } from "vitest";
 import {
+  arrangePluginNavPanelPreferences,
   arrangePluginNavPanels,
   getPluginNavPanelKey,
-  seedLeadingNavPanelKeys,
+  migrateLegacyHiddenPluginNavPanelOrder,
+  togglePluginNavPanelVisibility,
 } from "./pluginNavSidebarOrder";
 
 function panel(pluginId: string, id: string) {
@@ -15,13 +17,12 @@ const tasks = panel("tasks", "board");
 
 describe("arrangePluginNavPanels", () => {
   it("falls back to registry order before the user has reordered anything", () => {
-    const { visible, normalizedOrder } = arrangePluginNavPanels({
+    const { ordered, normalizedOrder } = arrangePluginNavPanels({
       panels: [github, docs, tasks],
       storedOrder: [],
-      hiddenKeys: [],
     });
 
-    expect(visible.map(getPluginNavPanelKey)).toEqual([
+    expect(ordered.map(getPluginNavPanelKey)).toEqual([
       "github/pulls",
       "docs/vault",
       "tasks/board",
@@ -33,41 +34,223 @@ describe("arrangePluginNavPanels", () => {
     ]);
   });
 
-  it("splits hidden panels out while both lists keep the user's order", () => {
-    const { visible, hidden } = arrangePluginNavPanels({
+  it("appends newly installed panels last", () => {
+    const { ordered } = arrangePluginNavPanels({
       panels: [github, docs, tasks],
-      storedOrder: ["tasks/board", "docs/vault", "github/pulls"],
-      hiddenKeys: ["docs/vault", "tasks/board"],
+      storedOrder: ["tasks/board", "github/pulls"],
     });
 
-    expect(visible.map(getPluginNavPanelKey)).toEqual(["github/pulls"]);
-    expect(hidden.map(getPluginNavPanelKey)).toEqual([
+    expect(ordered.map(getPluginNavPanelKey)).toEqual([
       "tasks/board",
+      "github/pulls",
+      "docs/vault",
+    ]);
+  });
+
+  it("keeps unregistered keys in the normalized order", () => {
+    const { ordered, normalizedOrder } = arrangePluginNavPanels({
+      panels: [github, docs],
+      storedOrder: ["strudel/repl", "docs/vault", "github/pulls"],
+    });
+
+    expect(ordered.map(getPluginNavPanelKey)).toEqual([
+      "docs/vault",
+      "github/pulls",
+    ]);
+    expect(normalizedOrder).toEqual([
+      "strudel/repl",
       "docs/vault",
+      "github/pulls",
     ]);
   });
 });
 
-describe("seedLeadingNavPanelKeys", () => {
-  it("leaves an untouched order empty so registry order still wins", () => {
-    expect(seedLeadingNavPanelKeys([], ["__builtin__/tools"])).toEqual([]);
+describe("arrangePluginNavPanelPreferences", () => {
+  it("shows the first three ordered panels by default", () => {
+    const extra = panel("calendar", "agenda");
+    const result = arrangePluginNavPanelPreferences({
+      panels: [github, docs, tasks, extra],
+      storedOrder: ["tasks/board", "github/pulls"],
+      storedVisibleKeys: null,
+      defaultVisibleKeys: [],
+      defaultVisibleCount: 3,
+    });
+
+    expect(result.visible.map(getPluginNavPanelKey)).toEqual([
+      "tasks/board",
+      "github/pulls",
+      "docs/vault",
+    ]);
+    expect(result.ordered.map(getPluginNavPanelKey)).toEqual([
+      "tasks/board",
+      "github/pulls",
+      "docs/vault",
+      "calendar/agenda",
+    ]);
+    expect(result.visibleKeys).toEqual([
+      "tasks/board",
+      "github/pulls",
+      "docs/vault",
+    ]);
+    expect(result.normalizedVisibleKeys).toBeNull();
+  });
+
+  it("keeps an explicit empty visible list meaningful", () => {
+    const result = arrangePluginNavPanelPreferences({
+      panels: [github, docs, tasks],
+      storedOrder: [],
+      storedVisibleKeys: [],
+      defaultVisibleKeys: [],
+      defaultVisibleCount: 3,
+    });
+
+    expect(result.visible).toEqual([]);
+    expect(result.ordered.map(getPluginNavPanelKey)).toEqual([
+      "github/pulls",
+      "docs/vault",
+      "tasks/board",
+    ]);
+    expect(result.normalizedVisibleKeys).toEqual([]);
+  });
+
+  it("preserves visibility for a temporarily unregistered panel", () => {
+    const result = arrangePluginNavPanelPreferences({
+      panels: [github, docs, tasks],
+      storedOrder: ["future/main", "docs/vault", "github/pulls"],
+      storedVisibleKeys: ["future/main", "github/pulls", "future/main"],
+      defaultVisibleKeys: [],
+      defaultVisibleCount: 3,
+    });
+
+    expect(result.visible.map(getPluginNavPanelKey)).toEqual(["github/pulls"]);
+    expect(result.ordered.map(getPluginNavPanelKey)).toEqual([
+      "docs/vault",
+      "github/pulls",
+      "tasks/board",
+    ]);
+    expect(result.normalizedVisibleKeys).toEqual([
+      "future/main",
+      "github/pulls",
+    ]);
   });
 
-  it("prepends a built-in key that a customized order predates", () => {
+  it("keeps a newly installed panel unchecked", () => {
+    const result = arrangePluginNavPanelPreferences({
+      panels: [github, docs, tasks],
+      storedOrder: ["github/pulls", "docs/vault"],
+      storedVisibleKeys: ["github/pulls", "docs/vault"],
+      defaultVisibleKeys: [],
+      defaultVisibleCount: 3,
+    });
+
+    expect(result.visible.map(getPluginNavPanelKey)).toEqual([
+      "github/pulls",
+      "docs/vault",
+    ]);
+    expect(result.normalizedOrder).toEqual([
+      "github/pulls",
+      "docs/vault",
+      "tasks/board",
+    ]);
+  });
+
+  it("uses the master order for visible panels", () => {
+    const result = arrangePluginNavPanelPreferences({
+      panels: [github, docs, tasks],
+      storedOrder: ["tasks/board", "github/pulls", "docs/vault"],
+      storedVisibleKeys: ["docs/vault", "tasks/board"],
+      defaultVisibleKeys: [],
+      defaultVisibleCount: 3,
+    });
+
+    expect(result.visible.map(getPluginNavPanelKey)).toEqual([
+      "tasks/board",
+      "docs/vault",
+    ]);
+    expect(result.ordered.map(getPluginNavPanelKey)).toEqual([
+      "tasks/board",
+      "github/pulls",
+      "docs/vault",
+    ]);
+  });
+
+  it("keeps every default destination visible while limiting optional plugins", () => {
+    const newThread = panel("__bb__", "new-thread");
+    const searchThreads = panel("__bb__", "search-threads");
+    const extra = panel("calendar", "agenda");
+    const result = arrangePluginNavPanelPreferences({
+      panels: [newThread, searchThreads, github, docs, tasks, extra],
+      storedOrder: [
+        "github/pulls",
+        "__bb__/new-thread",
+        "docs/vault",
+        "__bb__/search-threads",
+        "tasks/board",
+        "calendar/agenda",
+      ],
+      storedVisibleKeys: null,
+      defaultVisibleKeys: [
+        "__bb__/new-thread",
+        "__bb__/search-threads",
+      ],
+      defaultVisibleCount: 3,
+    });
+
+    expect(result.visibleKeys).toEqual([
+      "github/pulls",
+      "__bb__/new-thread",
+      "docs/vault",
+      "__bb__/search-threads",
+      "tasks/board",
+    ]);
+  });
+});
+
+describe("legacy hidden-panel migration", () => {
+  it("moves hidden keys behind visible keys while preserving both orders", () => {
     expect(
-      seedLeadingNavPanelKeys(
-        ["github/pulls", "docs/vault"],
-        ["__builtin__/tools"],
+      migrateLegacyHiddenPluginNavPanelOrder(
+        ["tasks/board", "docs/vault", "github/pulls", "docs/vault"],
+        ["tasks/board", "docs/vault"],
       ),
-    ).toEqual(["__builtin__/tools", "github/pulls", "docs/vault"]);
+    ).toEqual(["github/pulls", "tasks/board", "docs/vault"]);
+  });
+
+  it("retains a hidden key missing from the stored order", () => {
+    expect(
+      migrateLegacyHiddenPluginNavPanelOrder(
+        ["github/pulls"],
+        ["docs/vault"],
+      ),
+    ).toEqual(["github/pulls", "docs/vault"]);
+  });
+});
+
+describe("togglePluginNavPanelVisibility", () => {
+  it("checks and unchecks panels without losing other keys", () => {
+    const checked = togglePluginNavPanelVisibility(
+      ["github/pulls", "future/main"],
+      "docs/vault",
+      true,
+    );
+
+    expect(checked).toEqual([
+      "github/pulls",
+      "future/main",
+      "docs/vault",
+    ]);
+    expect(
+      togglePluginNavPanelVisibility(checked, "github/pulls", false),
+    ).toEqual(["future/main", "docs/vault"]);
   });
 
-  it("keeps the user's slot for a built-in key they already moved", () => {
+  it("does not duplicate a checked panel", () => {
     expect(
-      seedLeadingNavPanelKeys(
-        ["github/pulls", "__builtin__/tools"],
-        ["__builtin__/tools"],
+      togglePluginNavPanelVisibility(
+        ["github/pulls", "github/pulls"],
+        "github/pulls",
+        true,
       ),
-    ).toEqual(["github/pulls", "__builtin__/tools"]);
+    ).toEqual(["github/pulls"]);
   });
 });
diff --git a/apps/app/src/components/plugin/pluginNavSidebarOrder.ts b/apps/app/src/components/plugin/pluginNavSidebarOrder.ts
index a4eaea4311..e9a8801d5b 100644
--- a/apps/app/src/components/plugin/pluginNavSidebarOrder.ts
+++ b/apps/app/src/components/plugin/pluginNavSidebarOrder.ts
@@ -5,6 +5,20 @@ interface PluginNavPanelIdentity {
   id: string;
 }
 
+export const BUILT_IN_SIDEBAR_NAVIGATION_KEYS = {
+  newThread: "__bb__/new-thread",
+  searchThreads: "__bb__/search-threads",
+  extensions: "__bb__/extensions",
+  automations: "__bb__/automations",
+} as const;
+
+export const DEFAULT_BUILT_IN_SIDEBAR_NAVIGATION_ORDER = [
+  BUILT_IN_SIDEBAR_NAVIGATION_KEYS.newThread,
+  BUILT_IN_SIDEBAR_NAVIGATION_KEYS.searchThreads,
+  BUILT_IN_SIDEBAR_NAVIGATION_KEYS.extensions,
+  BUILT_IN_SIDEBAR_NAVIGATION_KEYS.automations,
+] as const;
+
 export function getPluginNavPanelKey(panel: PluginNavPanelIdentity): string {
   return `${panel.pluginId}/${panel.id}`;
 }
@@ -12,57 +26,104 @@ export function getPluginNavPanelKey(panel: PluginNavPanelIdentity): string {
 interface ArrangePluginNavPanelsArgs<TPanel extends PluginNavPanelIdentity> {
   panels: readonly TPanel[];
   storedOrder: readonly string[];
-  hiddenKeys: readonly string[];
 }
 
 interface ArrangedPluginNavPanels<TPanel extends PluginNavPanelIdentity> {
-  visible: TPanel[];
-  hidden: TPanel[];
+  ordered: TPanel[];
   normalizedOrder: string[];
 }
 
+interface ArrangePluginNavPanelPreferencesArgs<
+  TPanel extends PluginNavPanelIdentity,
+> extends ArrangePluginNavPanelsArgs<TPanel> {
+  storedVisibleKeys: readonly string[] | null;
+  defaultVisibleKeys: readonly string[];
+  defaultVisibleCount: number;
+}
+
+interface ArrangedPluginNavPanelPreferences<
+  TPanel extends PluginNavPanelIdentity,
+> extends ArrangedPluginNavPanels<TPanel> {
+  visible: TPanel[];
+  visibleKeys: string[];
+  normalizedVisibleKeys: string[] | null;
+}
+
 export function arrangePluginNavPanels<TPanel extends PluginNavPanelIdentity>({
   panels,
   storedOrder,
-  hiddenKeys,
 }: ArrangePluginNavPanelsArgs<TPanel>): ArrangedPluginNavPanels<TPanel> {
-  const { ordered, normalizedOrder } = arrangeByStoredOrder({
+  return arrangeByStoredOrder({
     items: panels,
     getId: getPluginNavPanelKey,
     storedOrder,
   });
-
-  const hiddenSet = new Set(hiddenKeys);
-  const visible: TPanel[] = [];
-  const hidden: TPanel[] = [];
-  for (const panel of ordered) {
-    if (hiddenSet.has(getPluginNavPanelKey(panel))) hidden.push(panel);
-    else visible.push(panel);
-  }
-
-  return { visible, hidden, normalizedOrder };
 }
 
-export function seedLeadingNavPanelKeys(
-  order: readonly string[],
-  leadingKeys: readonly string[],
-): string[] {
-  const next = [...order];
-  if (next.length === 0) return next;
-  const missing = leadingKeys.filter((key) => !next.includes(key));
-  return missing.length === 0 ? next : [...missing, ...next];
+export function arrangePluginNavPanelPreferences<
+  TPanel extends PluginNavPanelIdentity,
+>({
+  panels,
+  storedOrder,
+  storedVisibleKeys,
+  defaultVisibleKeys,
+  defaultVisibleCount,
+}: ArrangePluginNavPanelPreferencesArgs<TPanel>): ArrangedPluginNavPanelPreferences<TPanel> {
+  const { ordered, normalizedOrder } = arrangePluginNavPanels({
+    panels,
+    storedOrder,
+  });
+  const normalizedVisibleKeys =
+    storedVisibleKeys === null
+      ? null
+      : [...new Set(storedVisibleKeys.filter((key) => key.length > 0))];
+  const defaultVisibleKeySet = new Set(defaultVisibleKeys);
+  const visibleKeys = normalizedVisibleKeys ?? [
+    ...ordered
+      .filter((panel) => defaultVisibleKeySet.has(getPluginNavPanelKey(panel)))
+      .map(getPluginNavPanelKey),
+    ...ordered
+      .filter((panel) => !defaultVisibleKeySet.has(getPluginNavPanelKey(panel)))
+      .slice(0, Math.max(0, defaultVisibleCount))
+      .map(getPluginNavPanelKey),
+  ];
+  const visibleSet = new Set(visibleKeys);
+
+  return {
+    ordered,
+    normalizedOrder,
+    visible: ordered.filter((panel) =>
+      visibleSet.has(getPluginNavPanelKey(panel)),
+    ),
+    visibleKeys: ordered
+      .map(getPluginNavPanelKey)
+      .filter((key) => visibleSet.has(key)),
+    normalizedVisibleKeys,
+  };
 }
 
-export function hidePluginNavPanel(
-  hiddenKeys: readonly string[],
+export function togglePluginNavPanelVisibility(
+  visibleKeys: readonly string[],
   key: string,
+  visible: boolean,
 ): string[] {
-  return hiddenKeys.includes(key) ? [...hiddenKeys] : [...hiddenKeys, key];
+  const normalized = [...new Set(visibleKeys.filter((item) => item.length > 0))];
+  if (visible) {
+    return normalized.includes(key) ? normalized : [...normalized, key];
+  }
+  return normalized.filter((item) => item !== key);
 }
 
-export function showPluginNavPanel(
+export function migrateLegacyHiddenPluginNavPanelOrder(
+  order: readonly string[],
   hiddenKeys: readonly string[],
-  key: string,
 ): string[] {
-  return hiddenKeys.filter((hiddenKey) => hiddenKey !== key);
+  const uniqueOrder = [
+    ...new Set([...order, ...hiddenKeys].filter((key) => key.length > 0)),
+  ];
+  const hidden = new Set(hiddenKeys);
+  return [
+    ...uniqueOrder.filter((key) => !hidden.has(key)),
+    ...uniqueOrder.filter((key) => hidden.has(key)),
+  ];
 }
diff --git a/apps/app/src/components/sidebar/AppSidebar.tsx b/apps/app/src/components/sidebar/AppSidebar.tsx
index 4bbfacf5b7..24e7ffa73d 100644
--- a/apps/app/src/components/sidebar/AppSidebar.tsx
+++ b/apps/app/src/components/sidebar/AppSidebar.tsx
@@ -13,6 +13,7 @@ import {
   SidebarMenuButton,
   SidebarMenuItem,
   useCloseMobileSidebar,
+  useSidebar,
 } from "@/components/ui/sidebar.js";
 import { ProjectList } from "./ProjectList";
 import { PluginThreadList } from "./PluginThreadList";
@@ -85,6 +86,8 @@ export function AppSidebar({
     label: "New thread",
   });
   const closeOnMobile = useCloseMobileSidebar();
+  const { isCompactViewport, openMobile } = useSidebar();
+  const [compactCustomizeMode, setCompactCustomizeMode] = useState(false);
   const [desktopInfo] = useState(getBbDesktopInfo);
   const [threadShortcutKeysById, setThreadShortcutKeysById] = useState<
     ReadonlyMap<string, SidebarThreadShortcutPresentation>
@@ -171,6 +174,13 @@ export function AppSidebar({
   );
 
   const isHiddenHostedBody = mobileHosted?.hidden === true;
+  const isCompactCustomizeModeActive =
+    isCompactViewport && compactCustomizeMode;
+  useEffect(() => {
+    if (!isCompactViewport || !openMobile || isHiddenHostedBody) {
+      setCompactCustomizeMode(false);
+    }
+  }, [isCompactViewport, isHiddenHostedBody, openMobile]);
   const activateVisibleThreadShortcut = useCallback(
     (index: number) =>
       isHiddenHostedBody ? false : activateThreadShortcut(index),
@@ -228,6 +238,8 @@ export function AppSidebar({
         </div>
       ) : null}
       <SidebarNavigationRegion
+        compactCustomizeMode={isCompactCustomizeModeActive}
+        onCompactCustomizeModeChange={setCompactCustomizeMode}
         onNavigate={closeOnMobile}
         splitEnabled
         toolsRoutePath={toolsRoutePath}
@@ -237,10 +249,17 @@ export function AppSidebar({
       />
       <div
         aria-hidden="true"
-        className="mx-2 my-2 shrink-0 border-t border-sidebar-border/25"
+        className={cn(
+          "mx-2 my-2 shrink-0 border-t border-sidebar-border/25",
+          isCompactCustomizeModeActive && "hidden",
+        )}
         data-testid="app-sidebar-navigation-divider"
       />
-      <SidebarContent>
+      <SidebarContent
+        className={cn(isCompactCustomizeModeActive && "hidden")}
+        aria-hidden={isCompactCustomizeModeActive ? true : undefined}
+        inert={isCompactCustomizeModeActive ? true : undefined}
+      >
         <PluginThreadList
           replacement={threadListReplacement}
           original={originalThreadList}
diff --git a/apps/app/src/components/sidebar/BuiltInSidebarNavigation.tsx b/apps/app/src/components/sidebar/BuiltInSidebarNavigation.tsx
index ec40b35299..b3c38b7c62 100644
--- a/apps/app/src/components/sidebar/BuiltInSidebarNavigation.tsx
+++ b/apps/app/src/components/sidebar/BuiltInSidebarNavigation.tsx
@@ -1,38 +1,118 @@
-import type { ComponentProps } from "react";
-import { PluginNavSidebarItems } from "@/components/plugin/PluginNavSidebarItems";
-import { ProjectListActionButtons } from "./ProjectList";
+import type { ComponentProps, MouseEvent as ReactMouseEvent } from "react";
+import { useNavigate } from "react-router-dom";
+import {
+  type BuiltInSidebarNavEntry,
+  ExtensionsNavSidebarItem,
+  PluginNavSidebarItems,
+} from "@/components/plugin/PluginNavSidebarItems";
+import { useAppCommandRunner } from "@/components/commands/AppCommandProvider";
+import { Icon } from "@bb/shared-ui/icon";
+import { usePluginNavPanelChrome } from "@/lib/plugin-nav-panel-chrome";
+import {
+  ProjectListNewThreadAction,
+  ProjectListSearchThreadsAction,
+} from "./ProjectList";
+import { DEFAULT_BUILT_IN_SIDEBAR_NAVIGATION_ORDER } from "@/components/plugin/pluginNavSidebarOrder";
 
 export type BuiltInSidebarNavigationProps = ComponentProps<
-  typeof ProjectListActionButtons
+  typeof ProjectListNewThreadAction
 > &
-  ComponentProps<typeof PluginNavSidebarItems>;
+  ComponentProps<typeof ProjectListSearchThreadsAction> &
+  ComponentProps<typeof PluginNavSidebarItems> & {
+    toolsRoutePath?: string;
+  };
 
 export function BuiltInSidebarNavigation({
+  compactCustomizeMode,
   newThreadSplit,
+  onCompactCustomizeModeChange,
   onNavigate,
   onNewChat,
   onSearchThreads,
   splitEnabled,
   toolsRoutePath,
 }: BuiltInSidebarNavigationProps) {
-  return (
-    <div className="contents" data-testid="built-in-sidebar-navigation">
-      <div
-        data-testid="app-sidebar-primary-actions"
-        className="shrink-0 px-2 py-2 group-data-[collapsible=icon]:hidden"
-      >
-        <ProjectListActionButtons
+  const navigate = useNavigate();
+  const commandRunner = useAppCommandRunner();
+  const pluginNavPanels = usePluginNavPanelChrome();
+  const builtInEntries: BuiltInSidebarNavEntry[] = [
+    {
+      kind: "built-in",
+      pluginId: "__bb__",
+      id: "new-thread",
+      title: "New thread",
+      icon: <Icon name="MessageSquarePlus" aria-hidden="true" />,
+      content: (
+        <ProjectListNewThreadAction
           splitEnabled={splitEnabled}
           newThreadSplit={newThreadSplit}
           onNewChat={onNewChat}
-          onSearchThreads={onSearchThreads}
+        />
+      ),
+      disabled: onNewChat === undefined,
+      onActivate: (event: ReactMouseEvent<HTMLButtonElement>) => {
+        if (event.metaKey || event.ctrlKey) {
+          newThreadSplit?.openInSplit();
+          return;
+        }
+        onNewChat?.();
+      },
+    },
+    {
+      kind: "built-in",
+      pluginId: "__bb__",
+      id: "search-threads",
+      title: "Search threads",
+      icon: <Icon name="Search" aria-hidden="true" />,
+      content: (
+        <ProjectListSearchThreadsAction onSearchThreads={onSearchThreads} />
+      ),
+      disabled: !commandRunner.isCommandAvailable("thread.search", null),
+      onActivate: () => {
+        onSearchThreads?.();
+        commandRunner.dispatch("thread.search", null);
+      },
+    },
+    ...(toolsRoutePath
+      ? [
+          {
+            kind: "built-in" as const,
+            pluginId: "__bb__" as const,
+            id: "extensions",
+            title: "Extensions",
+            icon: <Icon name="Toolbox" aria-hidden="true" />,
+            content: (
+              <ExtensionsNavSidebarItem
+                routePath={toolsRoutePath}
+                onNavigate={onNavigate}
+              />
+            ),
+            onActivate: () => {
+              onNavigate?.();
+              void navigate(toolsRoutePath);
+            },
+          },
+        ]
+      : []),
+  ];
+
+  return (
+    <div
+      className="contents"
+      data-testid="built-in-sidebar-navigation"
+      data-sidebar-navigation-unified="true"
+    >
+      <div className="contents" data-testid="app-sidebar-primary-actions">
+        <PluginNavSidebarItems
+          builtInEntries={builtInEntries}
+          compactCustomizeMode={compactCustomizeMode}
+          entries={pluginNavPanels}
+          leadingOrderKeys={DEFAULT_BUILT_IN_SIDEBAR_NAVIGATION_ORDER}
+          onCompactCustomizeModeChange={onCompactCustomizeModeChange}
+          onNavigate={onNavigate}
+          splitEnabled={splitEnabled}
         />
       </div>
-      <PluginNavSidebarItems
-        onNavigate={onNavigate}
-        splitEnabled={splitEnabled}
-        toolsRoutePath={toolsRoutePath}
-      />
     </div>
   );
 }
diff --git a/apps/app/src/components/sidebar/ProjectList.tsx b/apps/app/src/components/sidebar/ProjectList.tsx
index e5ed64550f..332f01b595 100644
--- a/apps/app/src/components/sidebar/ProjectList.tsx
+++ b/apps/app/src/components/sidebar/ProjectList.tsx
@@ -795,7 +795,7 @@ export function ProjectListNewThreadAction({
     >
       <Icon name="MessageSquarePlus" />
       <span className="flex min-w-0 flex-1 items-center gap-1.5">
-        <span className="min-w-0 truncate text-left">New thread</span>
+        <span className="min-w-0 flex-1 truncate text-left">New thread</span>
         {newThreadSplitIndicator.miniMap ? (
           <SplitPaneMiniMap
             slots={newThreadSplitIndicator.miniMap}
diff --git a/apps/app/src/components/sidebar/SidebarNavigationRegion.test.tsx b/apps/app/src/components/sidebar/SidebarNavigationRegion.test.tsx
index 491980c5fa..9fd41ea89e 100644
--- a/apps/app/src/components/sidebar/SidebarNavigationRegion.test.tsx
+++ b/apps/app/src/components/sidebar/SidebarNavigationRegion.test.tsx
@@ -1,6 +1,6 @@
 // @vitest-environment jsdom
 
-import { useEffect, useState } from "react";
+import { useEffect, useState, type MouseEventHandler } from "react";
 import { cleanup, fireEvent, render, screen } from "@testing-library/react";
 import { createStore, Provider } from "jotai";
 import { MemoryRouter, useLocation } from "react-router-dom";
@@ -17,6 +17,7 @@ import { SidebarNavigationRegion } from "./SidebarNavigationRegion";
 
 const mocks = vi.hoisted(() => ({
   dispatch: vi.fn(),
+  openNewThreadInSplit: vi.fn(),
   onSearchThreads: vi.fn(),
 }));
 
@@ -29,7 +30,31 @@ vi.mock("@/components/commands/AppCommandProvider", () => ({
   useIsAppCommandModifierHeld: () => false,
 }));
 vi.mock("@/components/plugin/PluginNavSidebarItems", () => ({
-  PluginNavSidebarItems: () => <div>BB plugin destinations</div>,
+  ExtensionsNavSidebarItem: () => <div>Extensions</div>,
+  PluginNavSidebarItems: ({
+    builtInEntries = [],
+    entries = [],
+  }: {
+    builtInEntries?: Array<{
+      id: string;
+      title: string;
+      onActivate: MouseEventHandler<HTMLButtonElement>;
+    }>;
+    entries?: Array<{ chrome: { pluginId: string; title: string } }>;
+  }) => (
+    <div>
+      {builtInEntries.map((entry) => (
+        <button key={entry.id} type="button" onClick={entry.onActivate}>
+          {entry.title}
+        </button>
+      ))}
+      {entries.map(({ chrome }) => (
+        <div key={chrome.pluginId} data-testid="built-in-plugin-entry">
+          {chrome.title}
+        </div>
+      ))}
+    </div>
+  ),
 }));
 vi.mock("./usePaneContentSplitDrag", () => ({
   usePaneContentSplitActions: () => ({
@@ -103,7 +128,7 @@ function Harness({ onOwnerMount }: { onOwnerMount: () => void }) {
     <>
       <SidebarNavigationRegion
         splitEnabled
-        newThreadSplit={{ openInSplit: vi.fn() }}
+        newThreadSplit={{ openInSplit: mocks.openNewThreadInSplit }}
         onNavigate={vi.fn()}
         onNewChat={vi.fn()}
         onSearchThreads={mocks.onSearchThreads}
@@ -158,10 +183,43 @@ afterEach(() => {
   window.localStorage.clear();
   vi.restoreAllMocks();
   mocks.dispatch.mockReset();
+  mocks.openNewThreadInSplit.mockReset();
   mocks.onSearchThreads.mockReset();
 });
 
 describe("SidebarNavigationRegion", () => {
+  it("preserves modifier-click for New thread in BB navigation", () => {
+    renderHarness();
+
+    fireEvent.click(screen.getByRole("button", { name: "New thread" }), {
+      metaKey: true,
+    });
+
+    expect(mocks.openNewThreadInSplit).toHaveBeenCalledOnce();
+  });
+
+  it("passes Automations through the plugin navigation row path", () => {
+    setPluginSlotRegistrations(
+      "automations",
+      registrationSet({
+        navPanels: [
+          {
+            id: "automations",
+            title: "Automations",
+            icon: "Calendar",
+            path: "automations",
+            component: () => null,
+          },
+        ],
+      }),
+    );
+    renderHarness();
+
+    expect(screen.getByTestId("built-in-plugin-entry").textContent).toBe(
+      "Automations",
+    );
+  });
+
   it("routes Search through the quick palette without inline search UI", () => {
     registerFixture();
     renderHarness();
diff --git a/apps/app/src/components/sidebar/SidebarNavigationRegion.tsx b/apps/app/src/components/sidebar/SidebarNavigationRegion.tsx
index 46db44e50e..3435d359a2 100644
--- a/apps/app/src/components/sidebar/SidebarNavigationRegion.tsx
+++ b/apps/app/src/components/sidebar/SidebarNavigationRegion.tsx
@@ -12,6 +12,7 @@ import type {
 } from "@get-bb/plugin-sdk";
 import { useLocation, useNavigate } from "react-router-dom";
 import { toast } from "sonner";
+import { cn } from "@bb/shared-ui/lib/utils";
 import {
   useAppCommandRunner,
   useAppCommandShortcut,
@@ -233,6 +234,9 @@ export function SidebarNavigationRegion(props: BuiltInSidebarNavigationProps) {
     <nav
       aria-label="Sidebar navigation"
       data-testid="sidebar-navigation-region"
+      className={cn(
+        props.compactCustomizeMode && "flex min-h-0 flex-1 flex-col",
+      )}
     >
       <PluginReplacementSlot
         replacement={replacement}
diff --git a/apps/app/src/components/sidebar/SidebarOverview.stories.tsx b/apps/app/src/components/sidebar/SidebarOverview.stories.tsx
index 8e3fb16dec..c6671ce692 100644
--- a/apps/app/src/components/sidebar/SidebarOverview.stories.tsx
+++ b/apps/app/src/components/sidebar/SidebarOverview.stories.tsx
@@ -44,7 +44,6 @@ import {
 import {
   AUTOMATIONS_PLUGIN_ID,
   AUTOMATIONS_PLUGIN_PANEL_PATH,
-  getSkillsRoutePath,
 } from "@/lib/route-paths";
 import { splitLayoutAtom } from "@/lib/split-layout/atoms";
 import {
@@ -267,7 +266,7 @@ function SidebarFrame({ children }: SidebarFrameProps) {
             <ProjectListActionButtons onNewChat={noop} />
           </div>
           {}
-          <PluginNavSidebarItems toolsRoutePath={getSkillsRoutePath()} />
+          <PluginNavSidebarItems />
           <div className="min-h-0 flex-1 overflow-y-auto">{children}</div>
           <div className="shrink-0 border-t border-sidebar-border/70 px-2 py-2">
             <button
diff --git a/apps/app/src/lib/plugin-nav-panel-chrome.ts b/apps/app/src/lib/plugin-nav-panel-chrome.ts
index bef43f2a15..d43bdbaa2c 100644
--- a/apps/app/src/lib/plugin-nav-panel-chrome.ts
+++ b/apps/app/src/lib/plugin-nav-panel-chrome.ts
@@ -17,7 +17,7 @@ const pluginNavPanelChromeSchema = z.object({
 
 export type PluginNavPanelChrome = z.infer<typeof pluginNavPanelChromeSchema>;
 
-interface PluginNavPanelChromeEntry {
+export interface PluginNavPanelChromeEntry {
   chrome: PluginNavPanelChrome;
   panel: PluginNavPanelSlot | null;
 }