From dd0f5de82009b2e2ad295ce3df1d9bfcd28f9554 Mon Sep 17 00:00:00 2001
From: Cliff Hall <cliff@futurescale.com>
Date: Fri, 29 May 2026 14:47:19 -0400
Subject: [PATCH] feat(sort): add SortToggle for Logs, History, and Network
 (#1371) (#1372)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* feat(sort): add SortToggle for Logs, History, and Network (#1371)

Introduces a reusable SortToggle element and wires it into the Logs,
History, and Network screens so users can flip chronological order.
Selection is persisted per-screen to localStorage under the
inspector.sortDirection.* namespace, with invalid stored values falling
back to the newest-first default.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* fix(logs): move auto-scroll checkbox left of the sort selector

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* refactor(logs): remove auto-scroll checkbox; ListToggle left of SortToggle

- Drops the Logs auto-scroll checkbox and its plumbing through
  LoggingScreen / InspectorView.
- Moves the ListToggle to the left of the SortToggle on the History
  and Network panel toolbars.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* refactor(sort): address review on #1372

- Hydrate sort direction synchronously (getInitialValueInEffect: false)
  to remove the one-frame newest-first flicker on first paint.
- Drop the redundant `[...matched].sort()` copy across the three panels;
  `.filter()` already returns a fresh array.
- Document why serializeSortDirection bypasses Mantine's default JSON
  stringify (raw enum value in storage).
- MemoryStorage.getItem: collapse `has` + `!` to `?? null`.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* fix(history): default the request list to collapsed for parity with Network

The History list opened expanded while Network opened collapsed; align
History with Network so both panels start in the same compact view.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* feat(history,network): persist list compact state to localStorage

Lifts the per-panel `compact` flag out of HistoryListPanel /
NetworkStreamPanel and into InspectorView's localStorage hooks, mirroring
the sort-direction shape:

  inspector.listCompact.history
  inspector.listCompact.network

Defaults to collapsed (compact=true) on both, with a corrupted-value
deserializer that clamps unknown strings back to the default.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* feat(servers,resources): persist ListToggle state to localStorage

Lifts the per-screen compact preference out of ServerListScreen and
ResourceControls into InspectorView's localStorage hooks, matching the
History/Network shape:

  inspector.listCompact.servers
  inspector.listCompact.resources

Servers and Resources both default to expanded (compact=false). For
ResourceControls the displayed compact is still derived from openSections
(so per-section accordion clicks still work locally), and only explicit
ListToggle clicks update the persisted preference — the handler computes
the next compact value from the click outcome rather than blindly
flipping, so a half-open accordion still records the right post-state.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* refactor(sort-toggle): switch to icon button matching ListToggle style

Replaces the Mantine Select with a subtle Button (or ActionIcon for the
subtle variant), using TbSortDescending2 for newest-first and
TbSortAscending2 for oldest-first. Clicking the button flips between the
two values.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* refactor(sort-toggle): restore Select with sort icon in rightSection

Reverts SortToggle to a Mantine Select with simplified labels ("Newest
First" / "Oldest First") and the corresponding TbSortDescending2 /
TbSortAscending2 icon in the rightSection, replacing the default chevron.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* fix(sort-toggle): swap icons so they match label direction

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* fix(sort-toggle): use down arrow for newest, up arrow for oldest

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* refactor(inspector-view): extract useSortDirection / useListCompact

Collapses seven near-identical useLocalStorage call sites in
InspectorView into two scoped helpers. Each helper carries the shared
namespace, serialize/deserialize adapters, and getInitialValueInEffect:
false; the call sites now read as "this screen has sort persisted to
this scope" rather than re-stating the storage shape every time.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* fix(sort-toggle): apply prettier formatting

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../SortToggle/SortToggle.stories.tsx         |  41 +++++
 .../elements/SortToggle/SortToggle.test.tsx   |  45 +++++
 .../elements/SortToggle/SortToggle.tsx        |  42 +++++
 .../HistoryListPanel.stories.tsx              |   4 +
 .../HistoryListPanel.test.tsx                 |  82 ++++++++-
 .../HistoryListPanel/HistoryListPanel.tsx     |  38 +++--
 .../LogStreamPanel/LogStreamPanel.stories.tsx |   4 +-
 .../LogStreamPanel/LogStreamPanel.test.tsx    |  45 +++--
 .../groups/LogStreamPanel/LogStreamPanel.tsx  |  33 ++--
 .../NetworkStreamPanel.stories.tsx            |   4 +
 .../NetworkStreamPanel.test.tsx               |  88 +++++++++-
 .../NetworkStreamPanel/NetworkStreamPanel.tsx |  39 +++--
 .../ResourceControls.stories.tsx              |   2 +
 .../ResourceControls.test.tsx                 |  49 ++++--
 .../ResourceControls/ResourceControls.tsx     |  38 +++--
 .../HistoryScreen/HistoryScreen.stories.tsx   |   4 +
 .../HistoryScreen/HistoryScreen.test.tsx      |   4 +
 .../screens/HistoryScreen/HistoryScreen.tsx   |  13 ++
 .../LoggingScreen/LoggingScreen.stories.tsx   |   4 +-
 .../LoggingScreen/LoggingScreen.test.tsx      |   4 +-
 .../screens/LoggingScreen/LoggingScreen.tsx   |  13 +-
 .../NetworkScreen/NetworkScreen.stories.tsx   |   4 +
 .../NetworkScreen/NetworkScreen.test.tsx      |   4 +
 .../screens/NetworkScreen/NetworkScreen.tsx   |  13 ++
 .../ResourcesScreen.stories.tsx               |   2 +
 .../ResourcesScreen/ResourcesScreen.test.tsx  |   2 +
 .../ResourcesScreen/ResourcesScreen.tsx       |   6 +
 .../ServerListScreen.stories.tsx              |   2 +
 .../ServerListScreen.test.tsx                 |   2 +
 .../ServerListScreen/ServerListScreen.tsx     |  13 +-
 .../InspectorView/InspectorView.test.tsx      | 155 +++++++++++++++++-
 .../views/InspectorView/InspectorView.tsx     | 100 ++++++++++-
 clients/web/src/test/setup.ts                 |  32 ++++
 33 files changed, 813 insertions(+), 118 deletions(-)
 create mode 100644 clients/web/src/components/elements/SortToggle/SortToggle.stories.tsx
 create mode 100644 clients/web/src/components/elements/SortToggle/SortToggle.test.tsx
 create mode 100644 clients/web/src/components/elements/SortToggle/SortToggle.tsx

diff --git a/clients/web/src/components/elements/SortToggle/SortToggle.stories.tsx b/clients/web/src/components/elements/SortToggle/SortToggle.stories.tsx
new file mode 100644
index 00000000..5f159c93
--- /dev/null
+++ b/clients/web/src/components/elements/SortToggle/SortToggle.stories.tsx
@@ -0,0 +1,41 @@
+import type { Meta, StoryObj } from "@storybook/react-vite";
+import { expect, fn, userEvent, within } from "storybook/test";
+import { SortToggle } from "./SortToggle";
+
+const meta: Meta<typeof SortToggle> = {
+  title: "Elements/SortToggle",
+  component: SortToggle,
+  args: {
+    onChange: fn(),
+  },
+};
+
+export default meta;
+type Story = StoryObj<typeof SortToggle>;
+
+export const NewestFirst: Story = {
+  args: {
+    value: "newest-first",
+  },
+};
+
+export const OldestFirst: Story = {
+  args: {
+    value: "oldest-first",
+  },
+};
+
+export const FlipsDirection: Story = {
+  args: {
+    value: "newest-first",
+  },
+  play: async ({ canvasElement, args }) => {
+    const body = within(canvasElement.ownerDocument.body);
+    const select = await body.findByRole("textbox", {
+      name: "Sort direction",
+    });
+    await userEvent.click(select);
+    await userEvent.click(await body.findByText("Oldest First"));
+    await expect(args.onChange).toHaveBeenCalledWith("oldest-first");
+  },
+};
diff --git a/clients/web/src/components/elements/SortToggle/SortToggle.test.tsx b/clients/web/src/components/elements/SortToggle/SortToggle.test.tsx
new file mode 100644
index 00000000..a921b451
--- /dev/null
+++ b/clients/web/src/components/elements/SortToggle/SortToggle.test.tsx
@@ -0,0 +1,45 @@
+import { describe, it, expect, vi } from "vitest";
+import userEvent from "@testing-library/user-event";
+import { renderWithMantine, screen } from "../../../test/renderWithMantine";
+import { SortToggle } from "./SortToggle";
+
+describe("SortToggle", () => {
+  it("renders the current value as the selected option", () => {
+    renderWithMantine(<SortToggle value="newest-first" onChange={() => {}} />);
+    expect(screen.getByDisplayValue("Newest First")).toBeInTheDocument();
+  });
+
+  it("renders 'Oldest First' when value is oldest-first", () => {
+    renderWithMantine(<SortToggle value="oldest-first" onChange={() => {}} />);
+    expect(screen.getByDisplayValue("Oldest First")).toBeInTheDocument();
+  });
+
+  it("uses the default aria-label", () => {
+    renderWithMantine(<SortToggle value="newest-first" onChange={() => {}} />);
+    expect(
+      screen.getByRole("textbox", { name: "Sort direction" }),
+    ).toBeInTheDocument();
+  });
+
+  it("honors a custom aria-label", () => {
+    renderWithMantine(
+      <SortToggle
+        value="newest-first"
+        onChange={() => {}}
+        aria-label="Logs sort"
+      />,
+    );
+    expect(
+      screen.getByRole("textbox", { name: "Logs sort" }),
+    ).toBeInTheDocument();
+  });
+
+  it("invokes onChange with the new direction when the user picks another option", async () => {
+    const user = userEvent.setup();
+    const onChange = vi.fn();
+    renderWithMantine(<SortToggle value="newest-first" onChange={onChange} />);
+    await user.click(screen.getByRole("textbox", { name: "Sort direction" }));
+    await user.click(await screen.findByText("Oldest First"));
+    expect(onChange).toHaveBeenCalledWith("oldest-first");
+  });
+});
diff --git a/clients/web/src/components/elements/SortToggle/SortToggle.tsx b/clients/web/src/components/elements/SortToggle/SortToggle.tsx
new file mode 100644
index 00000000..ea87b497
--- /dev/null
+++ b/clients/web/src/components/elements/SortToggle/SortToggle.tsx
@@ -0,0 +1,42 @@
+import { Select } from "@mantine/core";
+import { TbSortAscending2, TbSortDescending2 } from "react-icons/tb";
+
+export type SortDirection = "oldest-first" | "newest-first";
+
+export interface SortToggleProps {
+  value: SortDirection;
+  onChange: (next: SortDirection) => void;
+  "aria-label"?: string;
+}
+
+const OPTIONS: { value: SortDirection; label: string }[] = [
+  { value: "newest-first", label: "Newest First" },
+  { value: "oldest-first", label: "Oldest First" },
+];
+
+function isSortDirection(value: string | null): value is SortDirection {
+  return value === "oldest-first" || value === "newest-first";
+}
+
+export function SortToggle({
+  value,
+  onChange,
+  "aria-label": ariaLabel = "Sort direction",
+}: SortToggleProps) {
+  const Icon = value === "newest-first" ? TbSortDescending2 : TbSortAscending2;
+  return (
+    <Select
+      size="sm"
+      w={150}
+      data={OPTIONS}
+      value={value}
+      onChange={(next) => {
+        if (isSortDirection(next)) onChange(next);
+      }}
+      allowDeselect={false}
+      withCheckIcon={false}
+      rightSection={<Icon size={16} />}
+      aria-label={ariaLabel}
+    />
+  );
+}
diff --git a/clients/web/src/components/groups/HistoryListPanel/HistoryListPanel.stories.tsx b/clients/web/src/components/groups/HistoryListPanel/HistoryListPanel.stories.tsx
index 7516e22c..0e9a2aa7 100644
--- a/clients/web/src/components/groups/HistoryListPanel/HistoryListPanel.stories.tsx
+++ b/clients/web/src/components/groups/HistoryListPanel/HistoryListPanel.stories.tsx
@@ -13,6 +13,10 @@ const meta: Meta<typeof HistoryListPanel> = {
     onExport: fn(),
     onReplay: fn(),
     onTogglePin: fn(),
+    sortDirection: "newest-first",
+    onSortChange: fn(),
+    compact: true,
+    onToggleCompact: fn(),
   },
 };
 
diff --git a/clients/web/src/components/groups/HistoryListPanel/HistoryListPanel.test.tsx b/clients/web/src/components/groups/HistoryListPanel/HistoryListPanel.test.tsx
index 0b36ab8d..a9607724 100644
--- a/clients/web/src/components/groups/HistoryListPanel/HistoryListPanel.test.tsx
+++ b/clients/web/src/components/groups/HistoryListPanel/HistoryListPanel.test.tsx
@@ -66,6 +66,10 @@ const baseProps = {
   onExport: vi.fn(),
   onReplay: vi.fn(),
   onTogglePin: vi.fn(),
+  sortDirection: "newest-first" as const,
+  onSortChange: vi.fn(),
+  compact: true,
+  onToggleCompact: vi.fn(),
 };
 
 describe("HistoryListPanel", () => {
@@ -219,22 +223,82 @@ describe("HistoryListPanel", () => {
     expect(onTogglePin).toHaveBeenCalledWith("req-1");
   });
 
-  it("toggles compact list state when ListToggle is clicked", async () => {
-    const user = userEvent.setup();
+  it("renders entries newest-first by default", () => {
     renderWithMantine(
       <HistoryListPanel {...baseProps} entries={sampleEntries} />,
     );
-    // Initially expanded — Collapse buttons exist on each entry, and the
-    // ListToggle exposes its aria-label as "Collapse all".
-    expect(
-      screen.getAllByRole("button", { name: "Collapse" }).length,
-    ).toBeGreaterThan(0);
+    const methods = screen.getAllByText(
+      /tools\/call|resources\/read|tools\/list/,
+    );
+    expect(methods[0]).toHaveTextContent("tools/list");
+    expect(methods[methods.length - 1]).toHaveTextContent("tools/call");
+  });
 
-    await user.click(screen.getByRole("button", { name: "Collapse all" }));
+  it("reorders entries when sortDirection is oldest-first", () => {
+    renderWithMantine(
+      <HistoryListPanel
+        {...baseProps}
+        entries={sampleEntries}
+        sortDirection="oldest-first"
+      />,
+    );
+    const methods = screen.getAllByText(
+      /tools\/call|resources\/read|tools\/list/,
+    );
+    expect(methods[0]).toHaveTextContent("tools/call");
+    expect(methods[methods.length - 1]).toHaveTextContent("tools/list");
+  });
 
-    // After toggle, entries collapsed — they show Expand
+  it("invokes onSortChange when the user picks a new sort", async () => {
+    const user = userEvent.setup();
+    const onSortChange = vi.fn();
+    renderWithMantine(
+      <HistoryListPanel
+        {...baseProps}
+        entries={sampleEntries}
+        onSortChange={onSortChange}
+      />,
+    );
+    await user.click(
+      screen.getByRole("textbox", { name: "History sort direction" }),
+    );
+    await user.click(await screen.findByText("Oldest First"));
+    expect(onSortChange).toHaveBeenCalledWith("oldest-first");
+  });
+
+  it("renders entries collapsed when compact is true (default parity with Network)", () => {
+    renderWithMantine(
+      <HistoryListPanel {...baseProps} entries={sampleEntries} compact />,
+    );
     expect(
       screen.getAllByRole("button", { name: "Expand" }).length,
     ).toBeGreaterThan(0);
   });
+
+  it("renders entries expanded when compact is false", () => {
+    renderWithMantine(
+      <HistoryListPanel
+        {...baseProps}
+        entries={sampleEntries}
+        compact={false}
+      />,
+    );
+    expect(
+      screen.getAllByRole("button", { name: "Collapse" }).length,
+    ).toBeGreaterThan(0);
+  });
+
+  it("invokes onToggleCompact when the ListToggle is clicked", async () => {
+    const user = userEvent.setup();
+    const onToggleCompact = vi.fn();
+    renderWithMantine(
+      <HistoryListPanel
+        {...baseProps}
+        entries={sampleEntries}
+        onToggleCompact={onToggleCompact}
+      />,
+    );
+    await user.click(screen.getByRole("button", { name: "Expand all" }));
+    expect(onToggleCompact).toHaveBeenCalledTimes(1);
+  });
 });
diff --git a/clients/web/src/components/groups/HistoryListPanel/HistoryListPanel.tsx b/clients/web/src/components/groups/HistoryListPanel/HistoryListPanel.tsx
index 37fee63b..88385a62 100644
--- a/clients/web/src/components/groups/HistoryListPanel/HistoryListPanel.tsx
+++ b/clients/web/src/components/groups/HistoryListPanel/HistoryListPanel.tsx
@@ -1,4 +1,4 @@
-import { useMemo, useState } from "react";
+import { useMemo } from "react";
 import {
   Button,
   Group,
@@ -11,6 +11,10 @@ import {
 import type { MessageEntry, MessageMethod } from "@inspector/core/mcp/types.js";
 import { HistoryEntry } from "../HistoryEntry/HistoryEntry";
 import { ListToggle } from "../../elements/ListToggle/ListToggle";
+import {
+  SortToggle,
+  type SortDirection,
+} from "../../elements/SortToggle/SortToggle";
 import { extractMethod } from "../historyUtils.js";
 
 export interface HistoryListPanelProps {
@@ -22,6 +26,10 @@ export interface HistoryListPanelProps {
   onExport: () => void;
   onReplay: (id: string) => void;
   onTogglePin: (id: string) => void;
+  sortDirection: SortDirection;
+  onSortChange: (next: SortDirection) => void;
+  compact: boolean;
+  onToggleCompact: () => void;
 }
 
 const PanelContainer = Paper.withProps({
@@ -71,13 +79,19 @@ export function HistoryListPanel({
   onExport,
   onReplay,
   onTogglePin,
+  sortDirection,
+  onSortChange,
+  compact,
+  onToggleCompact,
 }: HistoryListPanelProps) {
-  const [compact, setCompact] = useState(false);
-
-  const filteredEntries = useMemo(
-    () => entries.filter((e) => matchesFilters(e, searchText, methodFilter)),
-    [entries, searchText, methodFilter],
-  );
+  const filteredEntries = useMemo(() => {
+    // `.filter()` returns a fresh array, so sorting in-place is safe.
+    const sorted = entries
+      .filter((e) => matchesFilters(e, searchText, methodFilter))
+      .sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+    if (sortDirection === "newest-first") sorted.reverse();
+    return sorted;
+  }, [entries, searchText, methodFilter, sortDirection]);
 
   const pinnedEntries = useMemo(
     () => filteredEntries.filter((e) => pinnedIds.has(e.id)),
@@ -97,11 +111,13 @@ export function HistoryListPanel({
         <Title order={4}>Requests</Title>
         <Group gap="xs">
           {hasResults && (
-            <ListToggle
-              compact={compact}
-              onToggle={() => setCompact((c) => !c)}
-            />
+            <ListToggle compact={compact} onToggle={onToggleCompact} />
           )}
+          <SortToggle
+            value={sortDirection}
+            onChange={onSortChange}
+            aria-label="History sort direction"
+          />
           <Button
             variant="default"
             onClick={onClearAll}
diff --git a/clients/web/src/components/groups/LogStreamPanel/LogStreamPanel.stories.tsx b/clients/web/src/components/groups/LogStreamPanel/LogStreamPanel.stories.tsx
index 5f5ed416..30ff29f4 100644
--- a/clients/web/src/components/groups/LogStreamPanel/LogStreamPanel.stories.tsx
+++ b/clients/web/src/components/groups/LogStreamPanel/LogStreamPanel.stories.tsx
@@ -19,10 +19,10 @@ const meta: Meta<typeof LogStreamPanel> = {
       alert: true,
       emergency: true,
     },
-    autoScroll: true,
-    onToggleAutoScroll: fn(),
     onClear: fn(),
     onExport: fn(),
+    sortDirection: "newest-first",
+    onSortChange: fn(),
   },
 };
 
diff --git a/clients/web/src/components/groups/LogStreamPanel/LogStreamPanel.test.tsx b/clients/web/src/components/groups/LogStreamPanel/LogStreamPanel.test.tsx
index b6f4828d..c24b91de 100644
--- a/clients/web/src/components/groups/LogStreamPanel/LogStreamPanel.test.tsx
+++ b/clients/web/src/components/groups/LogStreamPanel/LogStreamPanel.test.tsx
@@ -43,10 +43,10 @@ const baseProps = {
   entries,
   filterText: "",
   visibleLevels: allVisible,
-  autoScroll: true,
-  onToggleAutoScroll: vi.fn(),
   onClear: vi.fn(),
   onExport: vi.fn(),
+  sortDirection: "newest-first" as const,
+  onSortChange: vi.fn(),
 };
 
 describe("LogStreamPanel", () => {
@@ -149,18 +149,39 @@ describe("LogStreamPanel", () => {
     expect(onExport).toHaveBeenCalledTimes(1);
   });
 
-  it("invokes onToggleAutoScroll when the auto-scroll checkbox is clicked", async () => {
-    const user = userEvent.setup();
-    const onToggleAutoScroll = vi.fn();
-    renderWithMantine(
-      <LogStreamPanel {...baseProps} onToggleAutoScroll={onToggleAutoScroll} />,
+  it("renders entries newest-first by default", () => {
+    renderWithMantine(<LogStreamPanel {...baseProps} />);
+    const items = screen.getAllByText(
+      /Server started|Failed to read|Loading config|deprecated/,
     );
-    await user.click(screen.getByLabelText("Auto-scroll"));
-    expect(onToggleAutoScroll).toHaveBeenCalledTimes(1);
+    // Newest receivedAt is the warning entry; oldest is "Server started".
+    expect(items[0]).toHaveTextContent('{"code":42,"msg":"deprecated"}');
+    expect(items[items.length - 1]).toHaveTextContent("Server started");
   });
 
-  it("renders auto-scroll checkbox with correct checked state", () => {
-    renderWithMantine(<LogStreamPanel {...baseProps} autoScroll={false} />);
-    expect(screen.getByLabelText("Auto-scroll")).not.toBeChecked();
+  it("reorders entries when sortDirection is oldest-first", () => {
+    renderWithMantine(
+      <LogStreamPanel {...baseProps} sortDirection="oldest-first" />,
+    );
+    const items = screen.getAllByText(
+      /Server started|Failed to read|Loading config|deprecated/,
+    );
+    expect(items[0]).toHaveTextContent("Server started");
+    expect(items[items.length - 1]).toHaveTextContent(
+      '{"code":42,"msg":"deprecated"}',
+    );
+  });
+
+  it("invokes onSortChange when the user picks a new sort", async () => {
+    const user = userEvent.setup();
+    const onSortChange = vi.fn();
+    renderWithMantine(
+      <LogStreamPanel {...baseProps} onSortChange={onSortChange} />,
+    );
+    await user.click(
+      screen.getByRole("textbox", { name: "Logs sort direction" }),
+    );
+    await user.click(await screen.findByText("Oldest First"));
+    expect(onSortChange).toHaveBeenCalledWith("oldest-first");
   });
 });
diff --git a/clients/web/src/components/groups/LogStreamPanel/LogStreamPanel.tsx b/clients/web/src/components/groups/LogStreamPanel/LogStreamPanel.tsx
index b627618c..7295d1bb 100644
--- a/clients/web/src/components/groups/LogStreamPanel/LogStreamPanel.tsx
+++ b/clients/web/src/components/groups/LogStreamPanel/LogStreamPanel.tsx
@@ -1,7 +1,6 @@
 import { useMemo } from "react";
 import {
   Button,
-  Checkbox,
   Group,
   Paper,
   ScrollArea,
@@ -12,15 +11,19 @@ import {
 import type { LoggingLevel } from "@modelcontextprotocol/sdk/types.js";
 import { LogEntry } from "../../elements/LogEntry/LogEntry";
 import type { LogEntryData } from "../../elements/LogEntry/LogEntry";
+import {
+  SortToggle,
+  type SortDirection,
+} from "../../elements/SortToggle/SortToggle";
 
 export interface LogStreamPanelProps {
   entries: LogEntryData[];
   filterText: string;
   visibleLevels: Record<LoggingLevel, boolean>;
-  autoScroll: boolean;
-  onToggleAutoScroll: () => void;
   onClear: () => void;
   onExport: () => void;
+  sortDirection: SortDirection;
+  onSortChange: (next: SortDirection) => void;
 }
 
 const PanelContainer = Paper.withProps({
@@ -61,25 +64,29 @@ export function LogStreamPanel({
   entries,
   filterText,
   visibleLevels,
-  autoScroll,
-  onToggleAutoScroll,
   onClear,
   onExport,
+  sortDirection,
+  onSortChange,
 }: LogStreamPanelProps) {
-  const filteredEntries = useMemo(
-    () => entries.filter((e) => matchesFilters(e, filterText, visibleLevels)),
-    [entries, filterText, visibleLevels],
-  );
+  const filteredEntries = useMemo(() => {
+    // `.filter()` returns a fresh array, so sorting in-place is safe.
+    const sorted = entries
+      .filter((e) => matchesFilters(e, filterText, visibleLevels))
+      .sort((a, b) => a.receivedAt.getTime() - b.receivedAt.getTime());
+    if (sortDirection === "newest-first") sorted.reverse();
+    return sorted;
+  }, [entries, filterText, visibleLevels, sortDirection]);
 
   return (
     <PanelContainer>
       <Group justify="space-between" mb="sm">
         <Title order={4}>Log Stream</Title>
         <Group>
-          <Checkbox
-            label="Auto-scroll"
-            checked={autoScroll}
-            onChange={onToggleAutoScroll}
+          <SortToggle
+            value={sortDirection}
+            onChange={onSortChange}
+            aria-label="Logs sort direction"
           />
           <Button
             variant="default"
diff --git a/clients/web/src/components/groups/NetworkStreamPanel/NetworkStreamPanel.stories.tsx b/clients/web/src/components/groups/NetworkStreamPanel/NetworkStreamPanel.stories.tsx
index e5446d16..44d8e80f 100644
--- a/clients/web/src/components/groups/NetworkStreamPanel/NetworkStreamPanel.stories.tsx
+++ b/clients/web/src/components/groups/NetworkStreamPanel/NetworkStreamPanel.stories.tsx
@@ -12,6 +12,10 @@ const meta: Meta<typeof NetworkStreamPanel> = {
     visibleCategories: { auth: true, transport: true },
     onClear: fn(),
     onExport: fn(),
+    sortDirection: "newest-first",
+    onSortChange: fn(),
+    compact: true,
+    onToggleCompact: fn(),
   },
 };
 
diff --git a/clients/web/src/components/groups/NetworkStreamPanel/NetworkStreamPanel.test.tsx b/clients/web/src/components/groups/NetworkStreamPanel/NetworkStreamPanel.test.tsx
index ea301401..f97c1d59 100644
--- a/clients/web/src/components/groups/NetworkStreamPanel/NetworkStreamPanel.test.tsx
+++ b/clients/web/src/components/groups/NetworkStreamPanel/NetworkStreamPanel.test.tsx
@@ -27,6 +27,10 @@ const baseProps = {
   visibleCategories: { auth: true, transport: true } as const,
   onClear: vi.fn(),
   onExport: vi.fn(),
+  sortDirection: "newest-first" as const,
+  onSortChange: vi.fn(),
+  compact: true,
+  onToggleCompact: vi.fn(),
 };
 
 describe("NetworkStreamPanel", () => {
@@ -124,14 +128,88 @@ describe("NetworkStreamPanel", () => {
     expect(screen.getByRole("button", { name: "Export" })).toBeDisabled();
   });
 
-  it("toggles between compact and expanded list views", async () => {
-    const user = userEvent.setup();
-    renderWithMantine(<NetworkStreamPanel {...baseProps} />);
-    // List starts compact -> entry should show Expand button
+  it("renders entries collapsed when compact is true", () => {
+    renderWithMantine(<NetworkStreamPanel {...baseProps} compact />);
     expect(screen.getByRole("button", { name: "Expand" })).toBeInTheDocument();
-    await user.click(screen.getByRole("button", { name: "Expand all" }));
+  });
+
+  it("renders entries expanded when compact is false", () => {
+    renderWithMantine(<NetworkStreamPanel {...baseProps} compact={false} />);
     expect(
       screen.getByRole("button", { name: "Collapse" }),
     ).toBeInTheDocument();
   });
+
+  it("invokes onToggleCompact when the ListToggle is clicked", async () => {
+    const user = userEvent.setup();
+    const onToggleCompact = vi.fn();
+    renderWithMantine(
+      <NetworkStreamPanel {...baseProps} onToggleCompact={onToggleCompact} />,
+    );
+    await user.click(screen.getByRole("button", { name: "Expand all" }));
+    expect(onToggleCompact).toHaveBeenCalledTimes(1);
+  });
+
+  it("renders entries newest-first by default", () => {
+    const older: FetchRequestEntry = {
+      ...entry,
+      id: "older",
+      url: "https://example.com/older",
+      timestamp: new Date("2026-03-17T09:00:00Z"),
+    };
+    const newer: FetchRequestEntry = {
+      ...entry,
+      id: "newer",
+      url: "https://example.com/newer",
+      timestamp: new Date("2026-03-17T11:00:00Z"),
+    };
+    renderWithMantine(
+      <NetworkStreamPanel {...baseProps} entries={[older, newer]} />,
+    );
+    const urls = screen.getAllByText(/example\.com\//);
+    expect(urls[0]).toHaveTextContent("https://example.com/newer");
+    expect(urls[urls.length - 1]).toHaveTextContent(
+      "https://example.com/older",
+    );
+  });
+
+  it("reorders entries when sortDirection is oldest-first", () => {
+    const older: FetchRequestEntry = {
+      ...entry,
+      id: "older",
+      url: "https://example.com/older",
+      timestamp: new Date("2026-03-17T09:00:00Z"),
+    };
+    const newer: FetchRequestEntry = {
+      ...entry,
+      id: "newer",
+      url: "https://example.com/newer",
+      timestamp: new Date("2026-03-17T11:00:00Z"),
+    };
+    renderWithMantine(
+      <NetworkStreamPanel
+        {...baseProps}
+        entries={[newer, older]}
+        sortDirection="oldest-first"
+      />,
+    );
+    const urls = screen.getAllByText(/example\.com\//);
+    expect(urls[0]).toHaveTextContent("https://example.com/older");
+    expect(urls[urls.length - 1]).toHaveTextContent(
+      "https://example.com/newer",
+    );
+  });
+
+  it("invokes onSortChange when the user picks a new sort", async () => {
+    const user = userEvent.setup();
+    const onSortChange = vi.fn();
+    renderWithMantine(
+      <NetworkStreamPanel {...baseProps} onSortChange={onSortChange} />,
+    );
+    await user.click(
+      screen.getByRole("textbox", { name: "Network sort direction" }),
+    );
+    await user.click(await screen.findByText("Oldest First"));
+    expect(onSortChange).toHaveBeenCalledWith("oldest-first");
+  });
 });
diff --git a/clients/web/src/components/groups/NetworkStreamPanel/NetworkStreamPanel.tsx b/clients/web/src/components/groups/NetworkStreamPanel/NetworkStreamPanel.tsx
index 7c0d0564..9c0521b0 100644
--- a/clients/web/src/components/groups/NetworkStreamPanel/NetworkStreamPanel.tsx
+++ b/clients/web/src/components/groups/NetworkStreamPanel/NetworkStreamPanel.tsx
@@ -1,4 +1,4 @@
-import { useMemo, useState } from "react";
+import { useMemo } from "react";
 import {
   Button,
   Group,
@@ -14,6 +14,10 @@ import type {
 } from "@inspector/core/mcp/types.js";
 import { NetworkEntry } from "../NetworkEntry/NetworkEntry";
 import { ListToggle } from "../../elements/ListToggle/ListToggle";
+import {
+  SortToggle,
+  type SortDirection,
+} from "../../elements/SortToggle/SortToggle";
 
 export interface NetworkStreamPanelProps {
   entries: FetchRequestEntry[];
@@ -21,6 +25,10 @@ export interface NetworkStreamPanelProps {
   visibleCategories: Record<FetchRequestCategory, boolean>;
   onClear: () => void;
   onExport: () => void;
+  sortDirection: SortDirection;
+  onSortChange: (next: SortDirection) => void;
+  compact: boolean;
+  onToggleCompact: () => void;
 }
 
 const PanelContainer = Paper.withProps({
@@ -82,14 +90,19 @@ export function NetworkStreamPanel({
   visibleCategories,
   onClear,
   onExport,
+  sortDirection,
+  onSortChange,
+  compact,
+  onToggleCompact,
 }: NetworkStreamPanelProps) {
-  const [compact, setCompact] = useState(true);
-
-  const filteredEntries = useMemo(
-    () =>
-      entries.filter((e) => matchesFilters(e, filterText, visibleCategories)),
-    [entries, filterText, visibleCategories],
-  );
+  const filteredEntries = useMemo(() => {
+    // `.filter()` returns a fresh array, so sorting in-place is safe.
+    const sorted = entries
+      .filter((e) => matchesFilters(e, filterText, visibleCategories))
+      .sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+    if (sortDirection === "newest-first") sorted.reverse();
+    return sorted;
+  }, [entries, filterText, visibleCategories, sortDirection]);
 
   const hasEntries = entries.length > 0;
   const hasResults = filteredEntries.length > 0;
@@ -100,11 +113,13 @@ export function NetworkStreamPanel({
         <Title order={4}>{formatTitle(filteredEntries.length)}</Title>
         <Group gap="xs">
           {hasResults && (
-            <ListToggle
-              compact={compact}
-              onToggle={() => setCompact((c) => !c)}
-            />
+            <ListToggle compact={compact} onToggle={onToggleCompact} />
           )}
+          <SortToggle
+            value={sortDirection}
+            onChange={onSortChange}
+            aria-label="Network sort direction"
+          />
           <Button variant="default" onClick={onClear} disabled={!hasEntries}>
             Clear
           </Button>
diff --git a/clients/web/src/components/groups/ResourceControls/ResourceControls.stories.tsx b/clients/web/src/components/groups/ResourceControls/ResourceControls.stories.tsx
index 42534799..98c8144f 100644
--- a/clients/web/src/components/groups/ResourceControls/ResourceControls.stories.tsx
+++ b/clients/web/src/components/groups/ResourceControls/ResourceControls.stories.tsx
@@ -16,6 +16,8 @@ const meta: Meta<typeof ResourceControls> = {
     onSelectTemplate: fn(),
     onUnsubscribeResource: fn(),
     listChanged: false,
+    compact: false,
+    onCompactChange: fn(),
   },
 };
 
diff --git a/clients/web/src/components/groups/ResourceControls/ResourceControls.test.tsx b/clients/web/src/components/groups/ResourceControls/ResourceControls.test.tsx
index 876b2fed..7f1be81a 100644
--- a/clients/web/src/components/groups/ResourceControls/ResourceControls.test.tsx
+++ b/clients/web/src/components/groups/ResourceControls/ResourceControls.test.tsx
@@ -33,6 +33,8 @@ const baseProps = {
   onSelectUri: vi.fn(),
   onSelectTemplate: vi.fn(),
   onUnsubscribeResource: vi.fn(),
+  compact: false,
+  onCompactChange: vi.fn(),
 };
 
 describe("ResourceControls", () => {
@@ -150,23 +152,40 @@ describe("ResourceControls", () => {
     expect(screen.getByText("Subscriptions (0)")).toBeInTheDocument();
   });
 
-  it("toggles all sections via the ListToggle button", async () => {
+  it("seeds the accordion to all-open when compact is false", () => {
+    renderWithMantine(<ResourceControls {...baseProps} compact={false} />);
+    // All three sections open → ListToggle reads "Collapse all".
+    expect(
+      screen.getByRole("button", { name: "Collapse all" }),
+    ).toBeInTheDocument();
+  });
+
+  it("seeds the accordion to all-closed when compact is true", () => {
+    renderWithMantine(<ResourceControls {...baseProps} compact />);
+    // All three sections closed → ListToggle reads "Expand all".
+    expect(
+      screen.getByRole("button", { name: "Expand all" }),
+    ).toBeInTheDocument();
+  });
+
+  it("invokes onCompactChange with the new preference when the ListToggle is clicked", async () => {
     const user = userEvent.setup();
-    renderWithMantine(<ResourceControls {...baseProps} />);
-    const toggleButtons = screen.getAllByRole("button");
-    // The list toggle is the last in the search row; just exercise it.
-    // Since all three sections start open, clicking it should collapse them.
-    const toggle = toggleButtons.find(
-      (btn) => btn.querySelector("svg") && btn !== toggleButtons[0],
+    const onCompactChange = vi.fn();
+    renderWithMantine(
+      <ResourceControls
+        {...baseProps}
+        compact={false}
+        onCompactChange={onCompactChange}
+      />,
     );
-    if (toggle) {
-      await user.click(toggle);
-    }
-    // After collapse, click again to re-expand.
-    if (toggle) {
-      await user.click(toggle);
-    }
-    expect(screen.getByText("URIs (2)")).toBeInTheDocument();
+    // All sections start open → ListToggle reads "Collapse all"; clicking
+    // it collapses everything and records compact=true.
+    await user.click(screen.getByRole("button", { name: "Collapse all" }));
+    expect(onCompactChange).toHaveBeenCalledWith(true);
+    // Now collapsed → ListToggle reads "Expand all"; clicking re-expands
+    // and records compact=false.
+    await user.click(screen.getByRole("button", { name: "Expand all" }));
+    expect(onCompactChange).toHaveBeenLastCalledWith(false);
   });
 
   it("filters by resource title when title is set", async () => {
diff --git a/clients/web/src/components/groups/ResourceControls/ResourceControls.tsx b/clients/web/src/components/groups/ResourceControls/ResourceControls.tsx
index 7e612064..01c58fc0 100644
--- a/clients/web/src/components/groups/ResourceControls/ResourceControls.tsx
+++ b/clients/web/src/components/groups/ResourceControls/ResourceControls.tsx
@@ -28,6 +28,13 @@ export interface ResourceControlsProps {
   onSelectUri: (uri: string) => void;
   onSelectTemplate: (uriTemplate: string) => void;
   onUnsubscribeResource: (uri: string) => void;
+  /**
+   * Persisted preference for the ListToggle. Seeds initial accordion state
+   * on mount; the user can still toggle individual sections during a session
+   * without affecting this value. Only an explicit ListToggle click updates it.
+   */
+  compact: boolean;
+  onCompactChange: (next: boolean) => void;
 }
 
 function panelMaxHeight(openCount: number): string {
@@ -52,6 +59,8 @@ export function ResourceControls({
   onSelectUri,
   onSelectTemplate,
   onUnsubscribeResource,
+  compact: initialCompact,
+  onCompactChange,
 }: ResourceControlsProps) {
   const [searchText, setSearchText] = useState("");
   const query = searchText.toLowerCase();
@@ -74,17 +83,27 @@ export function ResourceControls({
       s.resource.uri.toLowerCase().includes(query),
   );
 
-  const defaultOpen = [
-    ...(filteredResources.length > 0 ? ["resources"] : []),
-    ...(filteredTemplates.length > 0 ? ["templates"] : []),
-    ...(filteredSubscriptions.length > 0 ? ["subscriptions"] : []),
-  ];
-
   const allSections = ["resources", "templates", "subscriptions"];
-  const [openSections, setOpenSections] = useState<string[]>(defaultOpen);
+  // Seed the accordion from the persisted preference: empty when the user
+  // last left the panel compact, all three open when they explicitly
+  // expanded. Per-section accordion clicks during a session update the
+  // local list but don't change the persisted preference.
+  const [openSections, setOpenSections] = useState<string[]>(
+    initialCompact ? [] : [...allSections],
+  );
   const allExpanded = openSections.length === allSections.length;
   const maxHeight = panelMaxHeight(openSections.length);
 
+  function handleToggleList() {
+    // Compute the next compact value from what the click will produce so a
+    // half-open accordion (user toggled a single section) still persists the
+    // right preference: clicking "expand all" should record `compact=false`
+    // even if the visible state was already partially expanded.
+    const nextCompact = allExpanded;
+    setOpenSections(nextCompact ? [] : [...allSections]);
+    onCompactChange(nextCompact);
+  }
+
   return (
     <Stack gap="sm">
       <Group justify="space-between">
@@ -98,10 +117,7 @@ export function ResourceControls({
           value={searchText}
           onChange={(e) => setSearchText(e.currentTarget.value)}
         />
-        <ListToggle
-          compact={!allExpanded}
-          onToggle={() => setOpenSections(allExpanded ? [] : [...allSections])}
-        />
+        <ListToggle compact={!allExpanded} onToggle={handleToggleList} />
       </Group>
       <Accordion multiple value={openSections} onChange={setOpenSections}>
         <Accordion.Item value="resources">
diff --git a/clients/web/src/components/screens/HistoryScreen/HistoryScreen.stories.tsx b/clients/web/src/components/screens/HistoryScreen/HistoryScreen.stories.tsx
index 24f745ed..f65bdba1 100644
--- a/clients/web/src/components/screens/HistoryScreen/HistoryScreen.stories.tsx
+++ b/clients/web/src/components/screens/HistoryScreen/HistoryScreen.stories.tsx
@@ -13,6 +13,10 @@ const meta: Meta<typeof HistoryScreen> = {
     onExport: fn(),
     onReplay: fn(),
     onTogglePin: fn(),
+    sortDirection: "newest-first",
+    onSortChange: fn(),
+    compact: true,
+    onToggleCompact: fn(),
   },
 };
 
diff --git a/clients/web/src/components/screens/HistoryScreen/HistoryScreen.test.tsx b/clients/web/src/components/screens/HistoryScreen/HistoryScreen.test.tsx
index cf8a894c..f9d76a1b 100644
--- a/clients/web/src/components/screens/HistoryScreen/HistoryScreen.test.tsx
+++ b/clients/web/src/components/screens/HistoryScreen/HistoryScreen.test.tsx
@@ -26,6 +26,10 @@ const baseProps = {
   onExport: vi.fn(),
   onReplay: vi.fn(),
   onTogglePin: vi.fn(),
+  sortDirection: "newest-first" as const,
+  onSortChange: vi.fn(),
+  compact: true,
+  onToggleCompact: vi.fn(),
 };
 
 describe("HistoryScreen", () => {
diff --git a/clients/web/src/components/screens/HistoryScreen/HistoryScreen.tsx b/clients/web/src/components/screens/HistoryScreen/HistoryScreen.tsx
index 26aff28e..ccb5fa7f 100644
--- a/clients/web/src/components/screens/HistoryScreen/HistoryScreen.tsx
+++ b/clients/web/src/components/screens/HistoryScreen/HistoryScreen.tsx
@@ -4,6 +4,7 @@ import type { MessageEntry, MessageMethod } from "@inspector/core/mcp/types.js";
 import { HistoryControls } from "../../groups/HistoryControls/HistoryControls";
 import { HistoryListPanel } from "../../groups/HistoryListPanel/HistoryListPanel.js";
 import { extractMethod } from "../../groups/historyUtils.js";
+import type { SortDirection } from "../../elements/SortToggle/SortToggle";
 
 export interface HistoryScreenProps {
   entries: MessageEntry[];
@@ -12,6 +13,10 @@ export interface HistoryScreenProps {
   onExport: () => void;
   onReplay: (id: string) => void;
   onTogglePin: (id: string) => void;
+  sortDirection: SortDirection;
+  onSortChange: (next: SortDirection) => void;
+  compact: boolean;
+  onToggleCompact: () => void;
 }
 
 const ScreenLayout = Flex.withProps({
@@ -38,6 +43,10 @@ export function HistoryScreen({
   onExport,
   onReplay,
   onTogglePin,
+  sortDirection,
+  onSortChange,
+  compact,
+  onToggleCompact,
 }: HistoryScreenProps) {
   const [searchText, setSearchText] = useState("");
   const [methodFilter, setMethodFilter] = useState<MessageMethod | undefined>();
@@ -74,6 +83,10 @@ export function HistoryScreen({
         onExport={onExport}
         onReplay={onReplay}
         onTogglePin={onTogglePin}
+        sortDirection={sortDirection}
+        onSortChange={onSortChange}
+        compact={compact}
+        onToggleCompact={onToggleCompact}
       />
     </ScreenLayout>
   );
diff --git a/clients/web/src/components/screens/LoggingScreen/LoggingScreen.stories.tsx b/clients/web/src/components/screens/LoggingScreen/LoggingScreen.stories.tsx
index 0a26c2b5..655ed94a 100644
--- a/clients/web/src/components/screens/LoggingScreen/LoggingScreen.stories.tsx
+++ b/clients/web/src/components/screens/LoggingScreen/LoggingScreen.stories.tsx
@@ -13,8 +13,8 @@ const meta: Meta<typeof LoggingScreen> = {
     onSetLevel: fn(),
     onClear: fn(),
     onExport: fn(),
-    autoScroll: true,
-    onToggleAutoScroll: fn(),
+    sortDirection: "newest-first",
+    onSortChange: fn(),
   },
 };
 
diff --git a/clients/web/src/components/screens/LoggingScreen/LoggingScreen.test.tsx b/clients/web/src/components/screens/LoggingScreen/LoggingScreen.test.tsx
index e017e48d..70b97e80 100644
--- a/clients/web/src/components/screens/LoggingScreen/LoggingScreen.test.tsx
+++ b/clients/web/src/components/screens/LoggingScreen/LoggingScreen.test.tsx
@@ -9,8 +9,8 @@ const baseProps = {
   onSetLevel: vi.fn(),
   onClear: vi.fn(),
   onExport: vi.fn(),
-  autoScroll: true,
-  onToggleAutoScroll: vi.fn(),
+  sortDirection: "newest-first" as const,
+  onSortChange: vi.fn(),
 };
 
 describe("LoggingScreen", () => {
diff --git a/clients/web/src/components/screens/LoggingScreen/LoggingScreen.tsx b/clients/web/src/components/screens/LoggingScreen/LoggingScreen.tsx
index 9f1ae9ab..8eaf4446 100644
--- a/clients/web/src/components/screens/LoggingScreen/LoggingScreen.tsx
+++ b/clients/web/src/components/screens/LoggingScreen/LoggingScreen.tsx
@@ -4,6 +4,7 @@ import type { LoggingLevel } from "@modelcontextprotocol/sdk/types.js";
 import { LogControls } from "../../groups/LogControls/LogControls";
 import { LogStreamPanel } from "../../groups/LogStreamPanel/LogStreamPanel";
 import type { LogEntryData } from "../../elements/LogEntry/LogEntry";
+import type { SortDirection } from "../../elements/SortToggle/SortToggle";
 
 export interface LoggingScreenProps {
   entries: LogEntryData[];
@@ -11,8 +12,8 @@ export interface LoggingScreenProps {
   onSetLevel: (level: LoggingLevel) => void;
   onClear: () => void;
   onExport: () => void;
-  autoScroll: boolean;
-  onToggleAutoScroll: () => void;
+  sortDirection: SortDirection;
+  onSortChange: (next: SortDirection) => void;
 }
 
 const ALL_LEVELS_VISIBLE: Record<LoggingLevel, boolean> = {
@@ -60,8 +61,8 @@ export function LoggingScreen({
   onSetLevel,
   onClear,
   onExport,
-  autoScroll,
-  onToggleAutoScroll,
+  sortDirection,
+  onSortChange,
 }: LoggingScreenProps) {
   const [filterText, setFilterText] = useState("");
   const [visibleLevels, setVisibleLevels] =
@@ -95,10 +96,10 @@ export function LoggingScreen({
         entries={entries}
         filterText={filterText}
         visibleLevels={visibleLevels}
-        autoScroll={autoScroll}
-        onToggleAutoScroll={onToggleAutoScroll}
         onClear={onClear}
         onExport={onExport}
+        sortDirection={sortDirection}
+        onSortChange={onSortChange}
       />
     </ScreenLayout>
   );
diff --git a/clients/web/src/components/screens/NetworkScreen/NetworkScreen.stories.tsx b/clients/web/src/components/screens/NetworkScreen/NetworkScreen.stories.tsx
index 26c85565..56ef45d4 100644
--- a/clients/web/src/components/screens/NetworkScreen/NetworkScreen.stories.tsx
+++ b/clients/web/src/components/screens/NetworkScreen/NetworkScreen.stories.tsx
@@ -10,6 +10,10 @@ const meta: Meta<typeof NetworkScreen> = {
   args: {
     onClear: fn(),
     onExport: fn(),
+    sortDirection: "newest-first",
+    onSortChange: fn(),
+    compact: true,
+    onToggleCompact: fn(),
   },
 };
 
diff --git a/clients/web/src/components/screens/NetworkScreen/NetworkScreen.test.tsx b/clients/web/src/components/screens/NetworkScreen/NetworkScreen.test.tsx
index 9bb51f39..f081a4e1 100644
--- a/clients/web/src/components/screens/NetworkScreen/NetworkScreen.test.tsx
+++ b/clients/web/src/components/screens/NetworkScreen/NetworkScreen.test.tsx
@@ -43,6 +43,10 @@ const baseProps = {
   entries: [transportEntry, authEntry, errorEntry],
   onClear: vi.fn(),
   onExport: vi.fn(),
+  sortDirection: "newest-first" as const,
+  onSortChange: vi.fn(),
+  compact: true,
+  onToggleCompact: vi.fn(),
 };
 
 describe("NetworkScreen", () => {
diff --git a/clients/web/src/components/screens/NetworkScreen/NetworkScreen.tsx b/clients/web/src/components/screens/NetworkScreen/NetworkScreen.tsx
index d5d197b1..93f7c52a 100644
--- a/clients/web/src/components/screens/NetworkScreen/NetworkScreen.tsx
+++ b/clients/web/src/components/screens/NetworkScreen/NetworkScreen.tsx
@@ -6,11 +6,16 @@ import type {
 } from "@inspector/core/mcp/types.js";
 import { NetworkControls } from "../../groups/NetworkControls/NetworkControls";
 import { NetworkStreamPanel } from "../../groups/NetworkStreamPanel/NetworkStreamPanel";
+import type { SortDirection } from "../../elements/SortToggle/SortToggle";
 
 export interface NetworkScreenProps {
   entries: FetchRequestEntry[];
   onClear: () => void;
   onExport: () => void;
+  sortDirection: SortDirection;
+  onSortChange: (next: SortDirection) => void;
+  compact: boolean;
+  onToggleCompact: () => void;
 }
 
 const ALL_CATEGORIES_VISIBLE: Record<FetchRequestCategory, boolean> = {
@@ -44,6 +49,10 @@ export function NetworkScreen({
   entries,
   onClear,
   onExport,
+  sortDirection,
+  onSortChange,
+  compact,
+  onToggleCompact,
 }: NetworkScreenProps) {
   const [filterText, setFilterText] = useState("");
   const [visibleCategories, setVisibleCategories] = useState<
@@ -83,6 +92,10 @@ export function NetworkScreen({
         visibleCategories={visibleCategories}
         onClear={onClear}
         onExport={onExport}
+        sortDirection={sortDirection}
+        onSortChange={onSortChange}
+        compact={compact}
+        onToggleCompact={onToggleCompact}
       />
     </ScreenLayout>
   );
diff --git a/clients/web/src/components/screens/ResourcesScreen/ResourcesScreen.stories.tsx b/clients/web/src/components/screens/ResourcesScreen/ResourcesScreen.stories.tsx
index 72637d79..d63576e0 100644
--- a/clients/web/src/components/screens/ResourcesScreen/ResourcesScreen.stories.tsx
+++ b/clients/web/src/components/screens/ResourcesScreen/ResourcesScreen.stories.tsx
@@ -20,6 +20,8 @@ const meta: Meta<typeof ResourcesScreen> = {
     listChanged: false,
     subscriptions: [],
     templates: [],
+    compact: false,
+    onCompactChange: fn(),
   },
 };
 
diff --git a/clients/web/src/components/screens/ResourcesScreen/ResourcesScreen.test.tsx b/clients/web/src/components/screens/ResourcesScreen/ResourcesScreen.test.tsx
index efbca1bf..ccfca15f 100644
--- a/clients/web/src/components/screens/ResourcesScreen/ResourcesScreen.test.tsx
+++ b/clients/web/src/components/screens/ResourcesScreen/ResourcesScreen.test.tsx
@@ -26,6 +26,8 @@ const baseProps = {
   onReadResource: vi.fn(),
   onSubscribeResource: vi.fn(),
   onUnsubscribeResource: vi.fn(),
+  compact: false,
+  onCompactChange: vi.fn(),
 };
 
 const okResult: ReadResourceResult = {
diff --git a/clients/web/src/components/screens/ResourcesScreen/ResourcesScreen.tsx b/clients/web/src/components/screens/ResourcesScreen/ResourcesScreen.tsx
index bb8206a0..82372878 100644
--- a/clients/web/src/components/screens/ResourcesScreen/ResourcesScreen.tsx
+++ b/clients/web/src/components/screens/ResourcesScreen/ResourcesScreen.tsx
@@ -47,6 +47,8 @@ export interface ResourcesScreenProps {
     argumentValue: string,
     context: Record<string, string>,
   ) => Promise<string[]>;
+  compact: boolean;
+  onCompactChange: (next: boolean) => void;
 }
 
 const ScreenLayout = Flex.withProps({
@@ -112,6 +114,8 @@ export function ResourcesScreen({
   onSubscribeResource,
   onUnsubscribeResource,
   onCompleteArgument,
+  compact,
+  onCompactChange,
 }: ResourcesScreenProps) {
   const [selectedResourceUri, setSelectedResourceUri] = useState<
     string | undefined
@@ -252,6 +256,8 @@ export function ResourcesScreen({
             onSelectUri={handleSelectResource}
             onSelectTemplate={handleSelectTemplate}
             onUnsubscribeResource={onUnsubscribeResource}
+            compact={compact}
+            onCompactChange={onCompactChange}
           />
         </SidebarCard>
       </Sidebar>
diff --git a/clients/web/src/components/screens/ServerListScreen/ServerListScreen.stories.tsx b/clients/web/src/components/screens/ServerListScreen/ServerListScreen.stories.tsx
index b3405659..fe6ef744 100644
--- a/clients/web/src/components/screens/ServerListScreen/ServerListScreen.stories.tsx
+++ b/clients/web/src/components/screens/ServerListScreen/ServerListScreen.stories.tsx
@@ -18,6 +18,8 @@ const meta: Meta<typeof ServerListScreen> = {
     onEdit: fn(),
     onClone: fn(),
     onRemove: fn(),
+    compact: false,
+    onToggleCompact: fn(),
   },
 };
 
diff --git a/clients/web/src/components/screens/ServerListScreen/ServerListScreen.test.tsx b/clients/web/src/components/screens/ServerListScreen/ServerListScreen.test.tsx
index 37e1a163..1873425d 100644
--- a/clients/web/src/components/screens/ServerListScreen/ServerListScreen.test.tsx
+++ b/clients/web/src/components/screens/ServerListScreen/ServerListScreen.test.tsx
@@ -25,6 +25,8 @@ const baseProps = {
   onEdit: vi.fn(),
   onClone: vi.fn(),
   onRemove: vi.fn(),
+  compact: false,
+  onToggleCompact: vi.fn(),
 };
 
 describe("ServerListScreen", () => {
diff --git a/clients/web/src/components/screens/ServerListScreen/ServerListScreen.tsx b/clients/web/src/components/screens/ServerListScreen/ServerListScreen.tsx
index 846ce380..dd4dfa9e 100644
--- a/clients/web/src/components/screens/ServerListScreen/ServerListScreen.tsx
+++ b/clients/web/src/components/screens/ServerListScreen/ServerListScreen.tsx
@@ -1,4 +1,3 @@
-import { useState } from "react";
 import { ScrollArea, SimpleGrid, Stack, Text } from "@mantine/core";
 import type { ServerEntry } from "@inspector/core/mcp/types.js";
 import { ServerCard } from "../../groups/ServerCard/ServerCard";
@@ -19,6 +18,8 @@ export interface ServerListScreenProps {
   onEdit: (id: string) => void;
   onClone: (id: string) => void;
   onRemove: (id: string) => void;
+  compact: boolean;
+  onToggleCompact: () => void;
 }
 
 const PageContainer = Stack.withProps({
@@ -44,19 +45,15 @@ export function ServerListScreen({
   onEdit,
   onClone,
   onRemove,
+  compact,
+  onToggleCompact,
 }: ServerListScreenProps) {
-  const [compact, setCompact] = useState<boolean>(false);
-
-  function handleToggleList() {
-    setCompact((prev) => !prev);
-  }
-
   return (
     <PageContainer>
       <ServerListControls
         serverCount={servers.length}
         compact={compact}
-        onToggleList={handleToggleList}
+        onToggleList={onToggleCompact}
         onAddManually={onAddManually}
         onImportConfig={onImportConfig}
         onImportServerJson={onImportServerJson}
diff --git a/clients/web/src/components/views/InspectorView/InspectorView.test.tsx b/clients/web/src/components/views/InspectorView/InspectorView.test.tsx
index 768ca4c7..1dfdda1d 100644
--- a/clients/web/src/components/views/InspectorView/InspectorView.test.tsx
+++ b/clients/web/src/components/views/InspectorView/InspectorView.test.tsx
@@ -334,9 +334,9 @@ describe("InspectorView", () => {
     expect(onSetLogLevel).toHaveBeenCalledWith("warning");
   });
 
-  it("toggles autoScroll locally on the Logs screen after connecting", async () => {
+  it("persists Logs sort direction to localStorage and restores it on remount", async () => {
     const user = userEvent.setup();
-    renderWithMantine(
+    const { unmount } = renderWithMantine(
       <InspectorView
         {...makeProps({
           servers: [sampleServer],
@@ -350,11 +350,152 @@ describe("InspectorView", () => {
     const tabSelect = await screen.findByDisplayValue("Servers");
     await user.click(tabSelect);
     await user.click(await screen.findByText("Logs"));
-    const autoScroll = await screen.findByRole("checkbox", {
-      name: "Auto-scroll",
+
+    const sortSelect = await screen.findByRole("textbox", {
+      name: "Logs sort direction",
     });
-    expect(autoScroll).toBeChecked();
-    await user.click(autoScroll);
-    expect(autoScroll).not.toBeChecked();
+    expect(sortSelect).toHaveValue("Newest First");
+    await user.click(sortSelect);
+    await user.click(await screen.findByText("Oldest First"));
+
+    await waitFor(() =>
+      expect(window.localStorage.getItem("inspector.sortDirection.logs")).toBe(
+        "oldest-first",
+      ),
+    );
+
+    unmount();
+    renderWithMantine(
+      <InspectorView
+        {...makeProps({
+          servers: [sampleServer],
+          activeServer: "alpha",
+          connectionStatus: "connected",
+          initializeResult: connectedInit,
+          latencyMs: 50,
+        })}
+      />,
+    );
+    const tabSelect2 = await screen.findByDisplayValue("Servers");
+    await user.click(tabSelect2);
+    await user.click(await screen.findByText("Logs"));
+    const sortSelect2 = await screen.findByRole("textbox", {
+      name: "Logs sort direction",
+    });
+    await waitFor(() => expect(sortSelect2).toHaveValue("Oldest First"));
+  });
+
+  it("falls back to newest-first when a corrupted sort value is stored", async () => {
+    const user = userEvent.setup();
+    window.localStorage.setItem("inspector.sortDirection.history", "garbage");
+    renderWithMantine(
+      <InspectorView
+        {...makeProps({
+          servers: [sampleServer],
+          activeServer: "alpha",
+          connectionStatus: "connected",
+          initializeResult: connectedInit,
+          latencyMs: 50,
+        })}
+      />,
+    );
+    const tabSelect = await screen.findByDisplayValue("Servers");
+    await user.click(tabSelect);
+    await user.click(await screen.findByText("History"));
+    const sortSelect = await screen.findByRole("textbox", {
+      name: "History sort direction",
+    });
+    await waitFor(() => expect(sortSelect).toHaveValue("Newest First"));
+  });
+
+  it("persists History list compact state to localStorage and restores it on remount", async () => {
+    const user = userEvent.setup();
+    const historyEntry = {
+      id: "req-1",
+      timestamp: new Date("2026-03-17T10:00:00Z"),
+      direction: "request" as const,
+      message: {
+        jsonrpc: "2.0" as const,
+        id: 1,
+        method: "tools/list",
+      },
+    };
+    const { unmount } = renderWithMantine(
+      <InspectorView
+        {...makeProps({
+          servers: [sampleServer],
+          activeServer: "alpha",
+          connectionStatus: "connected",
+          initializeResult: connectedInit,
+          latencyMs: 50,
+          history: [historyEntry],
+        })}
+      />,
+    );
+    const tabSelect = await screen.findByDisplayValue("Servers");
+    await user.click(tabSelect);
+    await user.click(await screen.findByText("History"));
+    // Default is collapsed — ListToggle reads "Expand all".
+    await user.click(await screen.findByRole("button", { name: "Expand all" }));
+
+    await waitFor(() =>
+      expect(window.localStorage.getItem("inspector.listCompact.history")).toBe(
+        "false",
+      ),
+    );
+
+    unmount();
+    renderWithMantine(
+      <InspectorView
+        {...makeProps({
+          servers: [sampleServer],
+          activeServer: "alpha",
+          connectionStatus: "connected",
+          initializeResult: connectedInit,
+          latencyMs: 50,
+          history: [historyEntry],
+        })}
+      />,
+    );
+    const tabSelect2 = await screen.findByDisplayValue("Servers");
+    await user.click(tabSelect2);
+    await user.click(await screen.findByText("History"));
+    // After restore the list is expanded, so the ListToggle reads "Collapse all".
+    expect(
+      await screen.findByRole("button", { name: "Collapse all" }),
+    ).toBeInTheDocument();
+  });
+
+  it("falls back to collapsed when a corrupted compact value is stored", async () => {
+    const user = userEvent.setup();
+    window.localStorage.setItem("inspector.listCompact.history", "garbage");
+    const historyEntry = {
+      id: "req-1",
+      timestamp: new Date("2026-03-17T10:00:00Z"),
+      direction: "request" as const,
+      message: {
+        jsonrpc: "2.0" as const,
+        id: 1,
+        method: "tools/list",
+      },
+    };
+    renderWithMantine(
+      <InspectorView
+        {...makeProps({
+          servers: [sampleServer],
+          activeServer: "alpha",
+          connectionStatus: "connected",
+          initializeResult: connectedInit,
+          latencyMs: 50,
+          history: [historyEntry],
+        })}
+      />,
+    );
+    const tabSelect = await screen.findByDisplayValue("Servers");
+    await user.click(tabSelect);
+    await user.click(await screen.findByText("History"));
+    expect(
+      await screen.findByRole("button", { name: "Expand all" }),
+    ).toBeInTheDocument();
   });
 });
diff --git a/clients/web/src/components/views/InspectorView/InspectorView.tsx b/clients/web/src/components/views/InspectorView/InspectorView.tsx
index 3e8659fb..71c15245 100644
--- a/clients/web/src/components/views/InspectorView/InspectorView.tsx
+++ b/clients/web/src/components/views/InspectorView/InspectorView.tsx
@@ -1,5 +1,6 @@
 import { useMemo, useRef, useState, type ReactNode } from "react";
 import { AppShell, Box, Stack, Transition } from "@mantine/core";
+import { useLocalStorage } from "@mantine/hooks";
 import type {
   InitializeResult,
   LoggingLevel,
@@ -42,8 +43,68 @@ import { TasksScreen } from "../../screens/TasksScreen/TasksScreen";
 import type { TaskProgress } from "../../groups/TaskCard/TaskCard";
 import { HistoryScreen } from "../../screens/HistoryScreen/HistoryScreen";
 import { NetworkScreen } from "../../screens/NetworkScreen/NetworkScreen";
+import type { SortDirection } from "../../elements/SortToggle/SortToggle";
 import { getServerType } from "@inspector/core/mcp/config.js";
 
+const SORT_DEFAULT: SortDirection = "newest-first";
+
+// Storage adapters live alongside the view. The deserializer accepts anything
+// (manual edit, schema drift, future option removed) and clamps to the default
+// so the toggle never renders an unselectable state.
+function deserializeSortDirection(raw: string | undefined): SortDirection {
+  return raw === "oldest-first" || raw === "newest-first" ? raw : SORT_DEFAULT;
+}
+
+// Overrides Mantine's default `JSON.stringify` so the stored value is the
+// raw enum literal (`"oldest-first"`), not a JSON-quoted string. Keeps the
+// localStorage value human-readable and lets tests assert on it directly.
+function serializeSortDirection(value: SortDirection): string {
+  return value;
+}
+
+const LIST_COMPACT_DEFAULT = true;
+
+// Same shape as the sort adapters: store the boolean as `"true"` / `"false"`
+// so the localStorage value stays human-readable, and clamp any other value
+// back to the default rather than coercing it to `false`.
+function deserializeListCompact(raw: string | undefined): boolean {
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  return LIST_COMPACT_DEFAULT;
+}
+
+function serializeListCompact(value: boolean): string {
+  return value ? "true" : "false";
+}
+
+// One useLocalStorage call per scope, all with the same persistence shape.
+// `getInitialValueInEffect: false` reads synchronously on first render —
+// SPA only, no SSR — so the persisted value lands without a one-frame
+// flicker through the default. The `inspector.<kind>.<scope>` namespace
+// keeps related preferences grouped and easy to clear in bulk.
+function useSortDirection(scope: "logs" | "history" | "network") {
+  return useLocalStorage<SortDirection>({
+    key: `inspector.sortDirection.${scope}`,
+    defaultValue: SORT_DEFAULT,
+    deserialize: deserializeSortDirection,
+    serialize: serializeSortDirection,
+    getInitialValueInEffect: false,
+  });
+}
+
+function useListCompact(
+  scope: "history" | "network" | "servers" | "resources",
+  defaultValue: boolean,
+) {
+  return useLocalStorage<boolean>({
+    key: `inspector.listCompact.${scope}`,
+    defaultValue,
+    deserialize: deserializeListCompact,
+    serialize: serializeListCompact,
+    getInitialValueInEffect: false,
+  });
+}
+
 const SERVERS_TAB = "Servers";
 const NETWORK_TAB = "Network";
 
@@ -284,9 +345,30 @@ export function InspectorView({
   // dispatching live in the parent; this component only owns navigation
   // (which tab is visible) and a couple of view-local toggles.
   const [selectedTab, setSelectedTab] = useState<string>(SERVERS_TAB);
-  const [autoScroll, setAutoScroll] = useState<boolean>(true);
   const appRendererRef = useRef<AppRendererHandle>(null);
 
+  const [logsSort, setLogsSort] = useSortDirection("logs");
+  const [historySort, setHistorySort] = useSortDirection("history");
+  const [networkSort, setNetworkSort] = useSortDirection("network");
+
+  // Servers and Resources default to expanded (collapsed=false) so new
+  // users see content on first paint; History/Network default to
+  // collapsed (the lists are long enough that compact is the better
+  // first-paint state).
+  const [historyCompact, setHistoryCompact] = useListCompact(
+    "history",
+    LIST_COMPACT_DEFAULT,
+  );
+  const [networkCompact, setNetworkCompact] = useListCompact(
+    "network",
+    LIST_COMPACT_DEFAULT,
+  );
+  const [serversCompact, setServersCompact] = useListCompact("servers", false);
+  const [resourcesCompact, setResourcesCompact] = useListCompact(
+    "resources",
+    false,
+  );
+
   // Only show the non-Servers tabs when actually connected. Network is
   // additionally hidden for stdio servers — there is no HTTP traffic to
   // surface there, so the tab would always be empty. Capability-aware
@@ -380,6 +462,8 @@ export function InspectorView({
               onEdit={onServerEdit}
               onClone={onServerClone}
               onRemove={onServerRemove}
+              compact={serversCompact}
+              onToggleCompact={() => setServersCompact((c) => !c)}
             />
           </ScreenStage>
           <ScreenStage active={activeTab === "Tools"}>
@@ -431,6 +515,8 @@ export function InspectorView({
               onSubscribeResource={onSubscribeResource}
               onUnsubscribeResource={onUnsubscribeResource}
               onCompleteArgument={onCompleteArgument}
+              compact={resourcesCompact}
+              onCompactChange={setResourcesCompact}
             />
           </ScreenStage>
           <ScreenStage active={activeTab === "Tasks"}>
@@ -449,8 +535,8 @@ export function InspectorView({
               onSetLevel={onSetLogLevel}
               onClear={onClearLogs}
               onExport={onExportLogs}
-              autoScroll={autoScroll}
-              onToggleAutoScroll={() => setAutoScroll((prev) => !prev)}
+              sortDirection={logsSort}
+              onSortChange={setLogsSort}
             />
           </ScreenStage>
           <ScreenStage active={activeTab === "History"}>
@@ -461,6 +547,10 @@ export function InspectorView({
               onExport={onExportHistory}
               onReplay={onReplayHistory}
               onTogglePin={onTogglePinHistory}
+              sortDirection={historySort}
+              onSortChange={setHistorySort}
+              compact={historyCompact}
+              onToggleCompact={() => setHistoryCompact((c) => !c)}
             />
           </ScreenStage>
           <ScreenStage active={activeTab === "Network"}>
@@ -468,6 +558,10 @@ export function InspectorView({
               entries={network}
               onClear={onClearNetwork}
               onExport={onExportNetwork}
+              sortDirection={networkSort}
+              onSortChange={setNetworkSort}
+              compact={networkCompact}
+              onToggleCompact={() => setNetworkCompact((c) => !c)}
             />
           </ScreenStage>
         </ScreenStageContainer>
diff --git a/clients/web/src/test/setup.ts b/clients/web/src/test/setup.ts
index 2ba240b8..8bb39955 100644
--- a/clients/web/src/test/setup.ts
+++ b/clients/web/src/test/setup.ts
@@ -2,6 +2,38 @@ import "@testing-library/jest-dom/vitest";
 import { afterEach } from "vitest";
 import { cleanup } from "@testing-library/react";
 
+// Node 22+ exposes an experimental `localStorage` placeholder that overrides
+// happy-dom's implementation. Without `--localstorage-file`, it's an empty
+// stub with no methods, which breaks anything that calls setItem/getItem.
+// Install a minimal in-memory Storage shim before any test runs.
+class MemoryStorage implements Storage {
+  private store = new Map<string, string>();
+  get length(): number {
+    return this.store.size;
+  }
+  clear(): void {
+    this.store.clear();
+  }
+  getItem(key: string): string | null {
+    return this.store.get(key) ?? null;
+  }
+  key(index: number): string | null {
+    return Array.from(this.store.keys())[index] ?? null;
+  }
+  removeItem(key: string): void {
+    this.store.delete(key);
+  }
+  setItem(key: string, value: string): void {
+    this.store.set(key, String(value));
+  }
+}
+
+Object.defineProperty(window, "localStorage", {
+  configurable: true,
+  value: new MemoryStorage(),
+});
+
 afterEach(() => {
   cleanup();
+  window.localStorage.clear();
 });