@@ -555,6 +555,8 @@ vi.mock("./components/views/InspectorView/InspectorView", () => ({
         switch-servers-tab
       </button>
       <button onClick={() => props.onToggleConnection("A")}>connect</button>
+      {/* A second target, so a test can drive an A -> B -> A switch (#2095). */}
+      <button onClick={() => props.onToggleConnection("B")}>connect-b</button>
       <button onClick={() => props.onConnectionInfo()}>
         open-connection-info
       </button>
@@ -3538,6 +3540,74 @@ describe("App paginated list pagination toggle (#1721)", () => {
     };
     expect(lastPush?.paginatedLists).toBe(true);
   });
+
+  it("keeps the toggle on the last write after switching servers and back (#2095)", async () => {
+    // The override is what holds the display up while list reads are failing --
+    // the `servers` entry it would otherwise be read from is frozen at the last
+    // successful read, which this suite models exactly by mocking `useServers`
+    // to a fixed list.
+    //
+    // Held app-wide and cleared on every change of the *active* entry, it did
+    // not survive a plain server switch: A to B and back dropped it and the
+    // toggle fell back to that stale entry, reading `off` while disk, the
+    // tracker, and the client just built from it all said `on`. The lists were
+    // then rendered in all-pages mode showing an aggregate the client never
+    // fetched, with no Load-next-page control to fill them.
+    //
+    // Nothing here fails a list read explicitly: the fixed mock *is* that
+    // state, which is why one write is enough to reproduce it.
+    const user = userEvent.setup();
+    const previousUseServers = vi.mocked(useServers).getMockImplementation();
+    try {
+      vi.mocked(useServers).mockReturnValue({
+        servers: [
+          SERVER_A,
+          { ...SERVER_A, id: "B", name: "Other" },
+        ] as ServerEntry[],
+        loading: false,
+        error: undefined,
+        refresh: vi.fn().mockResolvedValue(undefined),
+        addServer: addServerSpy,
+        updateServer: updateServerSpy,
+        updateServerSettings: updateServerSettingsSpy,
+        removeServer: vi.fn(),
+        reorderServers: vi.fn(),
+        importSource: vi.fn().mockResolvedValue({ servers: {} }),
+      });
+      renderWithMantine(<App />);
+      await user.click(screen.getByText("connect"));
+      await waitFor(() => expect(clientInstances).toHaveLength(1));
+
+      await user.click(screen.getByText("paginated-on"));
+      await waitFor(() =>
+        expect(updateServerSettingsSpy).toHaveBeenCalledWith(
+          "A",
+          expect.objectContaining({ paginatedLists: true }),
+        ),
+      );
+      await waitFor(() =>
+        expect(screen.getByTestId("tools-paginated")).toHaveTextContent("true"),
+      );
+
+      // Away to B, whose own entry has never been written and so reads false.
+      await user.click(screen.getByText("connect-b"));
+      await waitFor(() =>
+        expect(screen.getByTestId("active-server")).toHaveTextContent("B"),
+      );
+      expect(screen.getByTestId("tools-paginated")).toHaveTextContent("false");
+
+      // ...and back to A, which is still paginated on disk.
+      await user.click(screen.getByText("connect"));
+      await waitFor(() =>
+        expect(screen.getByTestId("active-server")).toHaveTextContent("A"),
+      );
+      expect(screen.getByTestId("tools-paginated")).toHaveTextContent("true");
+    } finally {
+      if (previousUseServers) {
+        vi.mocked(useServers).mockImplementation(previousUseServers);
+      }
+    }
+  });
 });
 
 // A post-write reload failure rejects *after* the write landed, so every piece
 
@@ -116,6 +116,7 @@ import { usePagedPrompts } from "@inspector/core/react/usePagedPrompts.js";
 import { usePagedResources } from "@inspector/core/react/usePagedResources.js";
 import { usePaginatedList } from "./hooks/usePaginatedList";
 import { useLastPersistedSettings } from "./hooks/useLastPersistedSettings";
+import { usePaginatedListsOverride } from "./hooks/usePaginatedListsOverride";
 import { useValueChange } from "./hooks/useValueChange";
 import type { ListPaginationControlsProps } from "./components/elements/ListPaginationControls/ListPaginationControls";
 import { useManagedResourceTemplates } from "@inspector/core/react/useManagedResourceTemplates.js";
@@ -1234,26 +1235,15 @@ function App() {
   const activeServerEntry = servers.find((s) => s.id === activeServerId);
   const persistedPaginatedLists =
     activeServerEntry?.settings?.paginatedLists ?? false;
-  const [paginatedListsOverride, setPaginatedListsOverride] = useState<
-    boolean | null
-  >(null);
-  // Drop the optimistic override once the persisted value catches up (or the
-  // active server changes), so the persisted setting is the resting source.
-  //
-  // Keyed on the entry object rather than on the boolean it carries: the
-  // override can hold a *concrete* value (a rollback sets one instead of
-  // clearing), and if a later successful read reports the value that override
-  // replaced — an outside edit overtaking the write — the boolean and the
-  // server id are both unchanged and the UI stays stuck on it. Every successful
-  // read rebuilds the list, so the entry is the signal that supersedes it, and
-  // it subsumes the other two: the value is read off this entry, and switching
-  // servers selects a different one (#2089).
-  //
-  // Adjusted during render rather than in an effect, per this repo's rule
-  // against resetting state from render data in `useEffect` — the entry is
-  // referentially stable between reads, which is what `useValueChange` needs.
-  useValueChange(activeServerEntry, () => setPaginatedListsOverride(null));
-  const paginatedLists = paginatedListsOverride ?? persistedPaginatedLists;
+  // The optimistic override, held per server and superseded by the first
+  // successful list read that rebuilds that server's entry. Per server rather
+  // than one app-wide slot cleared on every active-entry change: the previous
+  // shape dropped the override on a plain server switch, so an A → B → A round
+  // trip fell back to A's stale entry and showed a value neither disk nor the
+  // live client held (#2095).
+  const paginatedListsOverride = usePaginatedListsOverride(servers);
+  const paginatedLists =
+    paginatedListsOverride.valueFor(activeServerId) ?? persistedPaginatedLists;
   // The malformed-entry report is written by the aggregate walk's salvage. In
   // paginated mode the tools/prompts/resources panels render the paged stores
   // instead, which never write or clear it — so it would linger above a page it
@@ -3968,9 +3958,13 @@ function App() {
   // gating reads it now, and a persisted PUT so it survives reconnects (#1721).
   const onTogglePaginatedLists = useCallback(
     (value: boolean) => {
-      setPaginatedListsOverride(value);
       const current = servers.find((s) => s.id === activeServerId);
       if (!current || activeServerId === undefined) return;
+      // Recorded against this server rather than app-wide, so it survives a
+      // switch away and back (#2095). Ordered after the id guard because the
+      // record is keyed by that id; with no active server there is nothing the
+      // toggle could have been flipped for.
+      paginatedListsOverride.record(activeServerId, value);
       // Not `current.settings` directly: that entry only advances on a
       // successful list read, so once one has failed it describes disk as it
       // was *before* the writes made since. Build on the last write known to
@@ -4019,8 +4013,16 @@ function App() {
       // already destroyed.
       const settlePaginationWrite = () => {
         const settled = write.landed(next);
-        if (settled && activeServerIdRef.current === activeServerId) {
-          setPaginatedListsOverride(next.paginatedLists ?? false);
+        if (!settled) return;
+        // The override is keyed by server, so it is re-applied whatever is
+        // active now — it is this server's value and is only ever displayed
+        // while this server is the active one. The live client is not: it
+        // belongs to whichever server is connected (#2095).
+        paginatedListsOverride.record(
+          activeServerId,
+          next.paginatedLists ?? false,
+        );
+        if (activeServerIdRef.current === activeServerId) {
           applyLiveServerSettings(next);
         }
       };
@@ -4061,17 +4063,25 @@ function App() {
           // `persistedPaginatedLists` — read from a `servers` entry that may be
           // stale, showing the same wrong value from the other side (#2089).
           //
-          // Applied only while this write's server is still the active one: the
-          // override is a single app-wide boolean and the live client belongs to
-          // whichever server is connected now, so a rejection arriving after the
-          // user switched would render this server's value on another one.
-          // The client is taken from the ref for the same reason the success
-          // path does: a reconnect to the same server passes the id check while
-          // this continuation's captured instance is already destroyed.
+          // The override is recorded whatever is active by the time this
+          // rejection arrives: it is keyed by this write's server and is only
+          // ever displayed while that server is the active one, so a switch in
+          // between costs nothing and dropping it would leave the stale entry
+          // to answer for A the next time it comes back (#2095).
+          //
+          // The live client is the half that stays gated — it belongs to
+          // whichever server is connected now, so pushing this server's value
+          // into it after a switch would apply it to another one. It is taken
+          // from the ref for the same reason the success path does: a reconnect
+          // to the same server passes the id check while this continuation's
+          // captured instance is already destroyed.
           const baseline =
             lastPersistedSettings.resolve(activeServerId) ?? EMPTY_SETTINGS;
+          paginatedListsOverride.record(
+            activeServerId,
+            baseline.paginatedLists ?? false,
+          );
           if (activeServerIdRef.current === activeServerId) {
-            setPaginatedListsOverride(baseline.paginatedLists ?? false);
             applyLiveServerSettings(baseline);
           }
           notifications.show({
@@ -4085,6 +4095,7 @@ function App() {
       servers,
       activeServerId,
       lastPersistedSettings,
+      paginatedListsOverride,
       applyLiveServerSettings,
       inspectorClient,
       updateServerSettings,
@@ -4513,8 +4524,9 @@ function App() {
       const write = lastPersistedSettings.begin(id);
       const settleSettingsWrite = () => {
         const settled = write.landed(value);
-        if (settled && activeServerIdRef.current === id) {
-          setPaginatedListsOverride(value.paginatedLists ?? false);
+        if (!settled) return;
+        paginatedListsOverride.record(id, value.paginatedLists ?? false);
+        if (activeServerIdRef.current === id) {
           applyLiveServerSettings(value);
         }
       };
@@ -4541,9 +4553,11 @@ function App() {
         // write is the account of it and nothing else will re-apply it. Same
         // reconciliation the toggle's own failure path does.
         const baseline = lastPersistedSettings.resolve(id);
-        if (baseline && activeServerIdRef.current === id) {
-          setPaginatedListsOverride(baseline.paginatedLists ?? false);
-          applyLiveServerSettings(baseline);
+        if (baseline) {
+          paginatedListsOverride.record(id, baseline.paginatedLists ?? false);
+          if (activeServerIdRef.current === id) {
+            applyLiveServerSettings(baseline);
+          }
         }
         throw err;
       }
 
@@ -0,0 +1,148 @@
+import { describe, it, expect } from "vitest";
+import { act } from "react";
+import type { ServerEntry } from "@inspector/core/mcp/types.js";
+import { renderWithMantine } from "../test/renderWithMantine";
+import {
+  usePaginatedListsOverride,
+  type PaginatedListsOverride,
+} from "./usePaginatedListsOverride";
+
+/**
+ * One `servers` entry, a fresh object per call — every test here turns on
+ * object identity, so a shared fixture would defeat them. A list rebuilt from
+ * fresh calls is what a successful `GET /api/servers` produces.
+ */
+const entry = (id: string): ServerEntry => ({
+  id,
+  name: id,
+  config: { type: "stdio", command: "node" },
+  connection: { status: "disconnected" },
+});
+
+interface Harness {
+  /** The hook's API as of the latest render. */
+  api: () => PaginatedListsOverride;
+  /** Deliver a new server list, as a successful list read would. */
+  setServers: (next: ServerEntry[]) => void;
+}
+
+function harness(initial: ServerEntry[]): Harness {
+  let latest: PaginatedListsOverride | undefined;
+  function Probe({ servers }: { servers: ServerEntry[] }) {
+    latest = usePaginatedListsOverride(servers);
+    return null;
+  }
+  const { rerender } = renderWithMantine(<Probe servers={initial} />);
+  return {
+    api: () => {
+      if (!latest) throw new Error("hook did not render");
+      return latest;
+    },
+    setServers: (next) => {
+      act(() => rerender(<Probe servers={next} />));
+    },
+  };
+}
+
+describe("usePaginatedListsOverride", () => {
+  it("reports no override before anything is recorded", () => {
+    const { api } = harness([entry("A")]);
+    expect(api().valueFor("A")).toBeUndefined();
+  });
+
+  it("reports nothing for an undefined server id", () => {
+    // No server is active before the first connect, and the composition root
+    // asks for the display value on every render regardless.
+    const { api } = harness([entry("A")]);
+    act(() => api().record("A", true));
+    expect(api().valueFor(undefined)).toBeUndefined();
+  });
+
+  it("returns what was recorded for that server", () => {
+    const { api } = harness([entry("A")]);
+    act(() => api().record("A", true));
+    expect(api().valueFor("A")).toBe(true);
+  });
+
+  it("does not apply one server's override to another", () => {
+    // The override is the *display* value, and the settings modal can be saved
+    // for a server that is not the connected one — so a record made for B must
+    // not change what A renders.
+    const { api } = harness([entry("A"), entry("B")]);
+    act(() => api().record("B", true));
+    expect(api().valueFor("A")).toBeUndefined();
+    expect(api().valueFor("B")).toBe(true);
+  });
+
+  it("survives a server switch away and back (#2095)", () => {
+    // Nothing about the list changes here — only which server is being asked
+    // about, which is all a switch is. The previous app-wide slot was cleared
+    // on every change of the active entry, which is what dropped A's value.
+    const { api } = harness([entry("A"), entry("B")]);
+    act(() => api().record("A", true));
+    expect(api().valueFor("B")).toBeUndefined();
+    expect(api().valueFor("A")).toBe(true);
+  });
+
+  it("keeps a record for each server", () => {
+    const { api } = harness([entry("A"), entry("B")]);
+    act(() => api().record("A", true));
+    act(() => api().record("B", false));
+    expect(api().valueFor("A")).toBe(true);
+    expect(api().valueFor("B")).toBe(false);
+  });
+
+  it("replaces its own record for the same server", () => {
+    const { api } = harness([entry("A")]);
+    act(() => api().record("A", true));
+    act(() => api().record("A", false));
+    expect(api().valueFor("A")).toBe(false);
+  });
+
+  it("stops applying once a fresh list read replaces that entry", () => {
+    const { api, setServers } = harness([entry("A")]);
+    act(() => api().record("A", true));
+    // A successful `GET /api/servers` rebuilds the list, so the entry is a new
+    // object even when the values are unchanged — which is exactly the case
+    // that has to supersede the override, since an edit made outside the
+    // Inspector can report back the value the override replaced.
+    setServers([entry("A")]);
+    expect(api().valueFor("A")).toBeUndefined();
+  });
+
+  it("keeps a record whose own entry was not re-read", () => {
+    // A read that rebuilds B says nothing about A. In practice the list is
+    // rebuilt wholesale, but the check is per entry and must not be widened to
+    // "any list change" — a reorder replaces the array while keeping every
+    // entry object, and is not evidence of a fresher read.
+    const a = entry("A");
+    const { api, setServers } = harness([a, entry("B")]);
+    act(() => api().record("A", true));
+    setServers([entry("B"), a]);
+    expect(api().valueFor("A")).toBe(true);
+  });
+
+  it("records against the list as it stands when the record is written", () => {
+    // A rollback records from a continuation that may be several renders old;
+    // pairing with the list captured then would make the record look superseded
+    // the moment it was written.
+    const { api, setServers } = harness([entry("A")]);
+    const stale = api();
+    setServers([entry("A")]);
+    act(() => stale.record("A", true));
+    expect(api().valueFor("A")).toBe(true);
+  });
+
+  it("drops superseded records rather than accumulating them", () => {
+    // Housekeeping, asserted through the only surface it has: a record dropped
+    // on the way past cannot come back, so re-reading after the entry is
+    // restored to the list still reports nothing.
+    const a = entry("A");
+    const { api, setServers } = harness([a, entry("B")]);
+    act(() => api().record("A", true));
+    setServers([entry("A"), entry("B")]);
+    act(() => api().record("B", true));
+    setServers([a, entry("B")]);
+    expect(api().valueFor("A")).toBeUndefined();
+  });
+});