@@ -128,14 +128,12 @@ describe("LayoutSection", () => {
     expect(screen.getByTestId("layout-row-3").dataset.selected).toBe("false");
   });
 
-  it("collapses the list when the section header is clicked", async () => {
+  it("collapses the list when expanded is false", async () => {
     // GIVEN
     const title = BasicBuilder.string();
-    const user = userEvent.setup();
-    render(<LayoutSection {...defaultProps} title={title} />);
 
     // WHEN
-    await user.click(screen.getByTestId(`layout-section-header-${title}`));
+    render(<LayoutSection {...defaultProps} title={title} expanded={false} />);
 
     // THEN
     await waitFor(() => {
@@ -145,16 +143,27 @@ describe("LayoutSection", () => {
     expect(screen.queryByTestId("layout-row-3")).not.toBeInTheDocument();
   });
 
-  it("expands the list when the collapsed section header is clicked again", async () => {
+  it("calls onToggleExpanded when the section header is clicked", async () => {
     // GIVEN
     const title = BasicBuilder.string();
+    const onToggleExpanded = jest.fn();
     const user = userEvent.setup();
-    render(<LayoutSection {...defaultProps} title={title} />);
+    render(<LayoutSection {...defaultProps} title={title} onToggleExpanded={onToggleExpanded} />);
 
-    // WHEN - collapse then expand
-    await user.click(screen.getByTestId(`layout-section-header-${title}`));
+    // WHEN
     await user.click(screen.getByTestId(`layout-section-header-${title}`));
 
+    // THEN
+    expect(onToggleExpanded).toHaveBeenCalledTimes(1);
+  });
+
+  it("shows items when expanded is true", () => {
+    // GIVEN
+    const title = BasicBuilder.string();
+
+    // WHEN
+    render(<LayoutSection {...defaultProps} title={title} expanded={true} />);
+
     // THEN
     expect(screen.getByTestId("layout-row-1")).toBeInTheDocument();
     expect(screen.getByTestId("layout-row-2")).toBeInTheDocument();
 
@@ -7,7 +7,7 @@
 
 import ArrowDropDownIcon from "@mui/icons-material/ArrowDropDown";
 import { ButtonBase, Collapse, Typography, List } from "@mui/material";
-import { MouseEvent, useCallback, useState } from "react";
+import { MouseEvent } from "react";
 
 import Stack from "@lichtblick/suite-base/components/Stack";
 import { Layout } from "@lichtblick/suite-base/services/ILayoutStorage";
@@ -18,11 +18,13 @@ import { useLayoutSectionStyles } from "./LayoutSection.style";
 export default function LayoutSection({
   title,
   disablePadding = false,
+  expanded = true,
   emptyText,
   items,
   anySelectedModifiedLayouts,
   multiSelectedIds,
   selectedId,
+  onToggleExpanded,
   onSelect,
   onRename,
   onDuplicate,
@@ -35,11 +37,13 @@ export default function LayoutSection({
 }: Readonly<{
   title: string | undefined;
   disablePadding?: boolean;
+  expanded?: boolean;
   emptyText: string | undefined;
   items: readonly Layout[] | undefined;
   anySelectedModifiedLayouts: boolean;
   multiSelectedIds: readonly string[];
   selectedId?: string;
+  onToggleExpanded?: () => void;
   onSelect: (item: Layout, params?: { selectedViaClick?: boolean; event?: MouseEvent }) => void;
   onRename: (item: Layout, newName: string) => void;
   onDuplicate: (item: Layout) => void;
@@ -51,11 +55,6 @@ export default function LayoutSection({
   onMakePersonalCopy: (item: Layout) => void;
 }>): React.JSX.Element {
   const { classes, cx } = useLayoutSectionStyles();
-  const [expanded, setExpanded] = useState(true);
-
-  const toggleExpanded = useCallback(() => {
-    setExpanded((prev) => !prev);
-  }, []);
 
   const isCollapsible = title != undefined;
 
@@ -64,7 +63,7 @@ export default function LayoutSection({
       {title != undefined && (
         <ButtonBase
           className={classes.sectionHeader}
-          onClick={toggleExpanded}
+          onClick={onToggleExpanded}
           disableRipple
           data-testid={`layout-section-header-${title}`}
         >
 
@@ -15,10 +15,13 @@ import {
 } from "@lichtblick/suite-base/context/CurrentLayoutContext";
 import { useCurrentUser } from "@lichtblick/suite-base/context/CurrentUserContext";
 import { useLayoutManager } from "@lichtblick/suite-base/context/LayoutManagerContext";
+import { useWorkspaceStore } from "@lichtblick/suite-base/context/Workspace/WorkspaceContext";
+import { useWorkspaceActions } from "@lichtblick/suite-base/context/Workspace/useWorkspaceActions";
 import { useAppConfigurationValue } from "@lichtblick/suite-base/hooks/useAppConfigurationValue";
 import { useConfirm } from "@lichtblick/suite-base/hooks/useConfirm";
 import { useLayoutNavigation } from "@lichtblick/suite-base/hooks/useLayoutNavigation";
 import { usePrompt } from "@lichtblick/suite-base/hooks/usePrompt";
+import { Layout } from "@lichtblick/suite-base/services/ILayoutStorage";
 import MockLayoutManager from "@lichtblick/suite-base/services/LayoutManager/MockLayoutManager";
 import LayoutBuilder from "@lichtblick/suite-base/testing/builders/LayoutBuilder";
 import { BasicBuilder } from "@lichtblick/test-builders";
@@ -62,6 +65,17 @@ jest.mock("@lichtblick/suite-base/hooks/useAppConfigurationValue", () => ({
   useAppConfigurationValue: jest.fn(),
 }));
 
+jest.mock("@lichtblick/suite-base/context/Workspace/WorkspaceContext", () => ({
+  useWorkspaceStore: jest.fn(),
+  WorkspaceStoreSelectors: {
+    selectLayoutSectionExpanded: jest.fn(),
+  },
+}));
+
+jest.mock("@lichtblick/suite-base/context/Workspace/useWorkspaceActions", () => ({
+  useWorkspaceActions: jest.fn(),
+}));
+
 jest.mock("@lichtblick/suite-base/hooks/useLayoutTransfer", () => ({
   useLayoutTransfer: jest.fn().mockReturnValue({
     importLayout: jest.fn(),
@@ -115,6 +129,13 @@ describe("LayoutBrowser", () => {
     (useConfirm as jest.Mock).mockReturnValue([jest.fn(), undefined]);
     (usePrompt as jest.Mock).mockReturnValue([jest.fn(), undefined]);
     (useAppConfigurationValue as jest.Mock).mockReturnValue([true, jest.fn()]);
+    (useWorkspaceStore as jest.Mock).mockReturnValue({ personal: true, shared: true });
+    (useWorkspaceActions as jest.Mock).mockReturnValue({
+      layoutBrowserActions: {
+        setPersonalSectionExpanded: jest.fn(),
+        setSharedSectionExpanded: jest.fn(),
+      },
+    });
     (useLayoutNavigation as jest.Mock).mockReturnValue({
       onSelectLayout: jest.fn(),
       state: {
@@ -251,4 +272,180 @@ describe("LayoutBrowser", () => {
       expect(dispatchMock).toHaveBeenCalledWith({ type: "clear-multi-action" });
     });
   });
+
+  describe("section collapse persistence", () => {
+    let setPersonalExpandedMock: jest.Mock;
+    let setSharedExpandedMock: jest.Mock;
+    let onSelectLayoutMock: jest.Mock;
+    let logEventMock: jest.Mock;
+
+    const originalLayoutSectionMock = jest.requireMock("./LayoutSection").default;
+
+    beforeEach(() => {
+      setPersonalExpandedMock = jest.fn();
+      setSharedExpandedMock = jest.fn();
+      onSelectLayoutMock = jest.fn().mockResolvedValue(undefined);
+      logEventMock = jest.fn().mockResolvedValue(undefined);
+
+      (useAnalytics as jest.Mock).mockReturnValue({ logEvent: logEventMock });
+      (useWorkspaceStore as jest.Mock).mockReturnValue({ personal: true, shared: true });
+      (useWorkspaceActions as jest.Mock).mockReturnValue({
+        layoutBrowserActions: {
+          setPersonalSectionExpanded: setPersonalExpandedMock,
+          setSharedSectionExpanded: setSharedExpandedMock,
+        },
+      });
+      (useLayoutNavigation as jest.Mock).mockReturnValue({
+        onSelectLayout: onSelectLayoutMock,
+        state: {
+          busy: false,
+          error: undefined,
+          online: true,
+          lastSelectedId: undefined,
+          multiAction: undefined,
+          selectedIds: [],
+        },
+        dispatch: dispatchMock,
+      });
+    });
+
+    afterEach(() => {
+      jest.requireMock("./LayoutSection").default = originalLayoutSectionMock;
+    });
+
+    it("passes expanded state and toggle handlers to LayoutSection", () => {
+      // GIVEN
+      (useWorkspaceStore as jest.Mock).mockReturnValue({ personal: false, shared: true });
+
+      const capturedProps: Record<string, unknown>[] = [];
+      jest.requireMock("./LayoutSection").default = jest
+        .fn()
+        .mockImplementation((props: Record<string, unknown>) => {
+          capturedProps.push(props);
+          return <div data-testid="layout-section" />;
+        });
+
+      // WHEN
+      render(<LayoutBrowser />);
+
+      // THEN
+      expect(capturedProps[0]?.expanded).toBe(false);
+      expect(capturedProps[0]?.onToggleExpanded).toBeDefined();
+    });
+
+    it("calls setPersonalSectionExpanded with toggler when togglePersonalExpanded is invoked", () => {
+      // GIVEN
+      let capturedOnToggle: (() => void) | undefined;
+      jest.requireMock("./LayoutSection").default = jest
+        .fn()
+        .mockImplementation((props: { onToggleExpanded?: () => void }) => {
+          if (!capturedOnToggle && props.onToggleExpanded) {
+            capturedOnToggle = props.onToggleExpanded;
+          }
+          return <div data-testid="layout-section" />;
+        });
+
+      render(<LayoutBrowser />);
+
+      // WHEN
+      capturedOnToggle!();
+
+      // THEN
+      expect(setPersonalExpandedMock).toHaveBeenCalledTimes(1);
+      expect(setPersonalExpandedMock).toHaveBeenCalledWith(expect.any(Function));
+    });
+
+    it("calls setSharedSectionExpanded with toggler when toggleSharedExpanded is invoked", () => {
+      // GIVEN
+      mockLayoutManager.supportsSharing = true;
+
+      const capturedOnToggles: (() => void)[] = [];
+      jest.requireMock("./LayoutSection").default = jest
+        .fn()
+        .mockImplementation((props: { onToggleExpanded?: () => void }) => {
+          if (props.onToggleExpanded) {
+            capturedOnToggles.push(props.onToggleExpanded);
+          }
+          return <div data-testid="layout-section" />;
+        });
+
+      render(<LayoutBrowser />);
+
+      // WHEN - second LayoutSection is the shared one
+      const sharedToggle = capturedOnToggles[1];
+      sharedToggle!();
+
+      // THEN
+      expect(setSharedExpandedMock).toHaveBeenCalledTimes(1);
+      expect(setSharedExpandedMock).toHaveBeenCalledWith(expect.any(Function));
+    });
+
+    it("expands personal section when creating a new layout", async () => {
+      // GIVEN
+      const newLayout = LayoutBuilder.layout();
+      mockLayoutManager.saveNewLayout = jest.fn().mockResolvedValue(newLayout);
+      render(<LayoutBrowser currentDateForStorybook={new Date("2025-01-01")} />);
+
+      // WHEN - simulate createNewLayout by clicking the button
+      const createBtn = screen.getByTestId("create-new-layout");
+      createBtn.click();
+
+      // THEN
+      await waitFor(() => {
+        expect(setPersonalExpandedMock).toHaveBeenCalledWith(true);
+      });
+    });
+
+    it("expands shared section when sharing a layout", async () => {
+      // GIVEN
+      const layout = LayoutBuilder.layout();
+      const newLayout = LayoutBuilder.layout();
+      const promptMock = jest.fn().mockResolvedValue("Shared Layout");
+      (usePrompt as jest.Mock).mockReturnValue([promptMock, undefined]);
+      mockLayoutManager.saveNewLayout = jest.fn().mockResolvedValue(newLayout);
+
+      let capturedOnShare: ((item: Layout) => void) | undefined;
+      jest.requireMock("./LayoutSection").default = jest
+        .fn()
+        .mockImplementation((props: { onShare: (item: Layout) => void }) => {
+          capturedOnShare = props.onShare;
+          return <div data-testid="layout-section" />;
+        });
+
+      render(<LayoutBrowser />);
+
+      // WHEN
+      capturedOnShare!(layout);
+
+      // THEN
+      await waitFor(() => {
+        expect(setSharedExpandedMock).toHaveBeenCalledWith(true);
+      });
+    });
+
+    it("expands personal section when making a personal copy", async () => {
+      // GIVEN
+      const layout = LayoutBuilder.layout();
+      const newLayout = LayoutBuilder.layout();
+      mockLayoutManager.makePersonalCopy = jest.fn().mockResolvedValue(newLayout);
+
+      let capturedOnMakePersonalCopy: ((item: Layout) => void) | undefined;
+      jest.requireMock("./LayoutSection").default = jest
+        .fn()
+        .mockImplementation((props: { onMakePersonalCopy: (item: Layout) => void }) => {
+          capturedOnMakePersonalCopy = props.onMakePersonalCopy;
+          return <div data-testid="layout-section" />;
+        });
+
+      render(<LayoutBrowser />);
+
+      // WHEN
+      capturedOnMakePersonalCopy!(layout);
+
+      // THEN
+      await waitFor(() => {
+        expect(setPersonalExpandedMock).toHaveBeenCalledWith(true);
+      });
+    });
+  });
 });