diff --git a/app/src/components/Header.tsx b/app/src/components/Header.tsx
index fc02c5c7..94148e3c 100644
--- a/app/src/components/Header.tsx
+++ b/app/src/components/Header.tsx
@@ -9,6 +9,18 @@ import { getNavigation } from '../../../config/navigation';
 
 const FEEDBACK_HREF = buildMailto({ subject: 'ProtSpace feedback' });
 
+// Ghost-style Feedback CTA: transparent, on-brand blue text/icon with a faint blue
+// hover — de-emphasized vs. the app-shell primary (#3c83f6). The hue is variant-aware
+// so the label clears WCAG AA on both header backgrounds: the canonical ProtSpace blue
+// (#00a3e0, ~5.6:1) on the dark header, and a darker shade (#006d96, ~5.3:1) on the
+// light Explore header, where #00a3e0 would only reach ~2.6:1.
+// Both literals are spelled out so Tailwind's source scan can generate the arbitrary
+// color utilities (it cannot see classes built from interpolated strings).
+const FEEDBACK_BUTTON_CLASS_DEFAULT =
+  'text-[#00a3e0] hover:bg-[#00a3e0]/10 hover:text-[#00a3e0] focus-visible:ring-[#00a3e0]';
+const FEEDBACK_BUTTON_CLASS_LIGHT =
+  'text-[#006d96] hover:bg-[#006d96]/10 hover:text-[#006d96] focus-visible:ring-[#006d96]';
+
 const mode = import.meta.env.MODE === 'production' ? 'production' : 'development';
 const navItems = getNavigation(mode);
 
@@ -31,6 +43,8 @@ const Header = ({ variant = 'default', className }: HeaderProps) => {
   const textClass = variant === 'light' ? 'text-slate-900' : 'text-foreground';
   const hoverTextClass = variant === 'light' ? 'hover:text-slate-700' : 'hover:text-primary';
   const mutedTextClass = variant === 'light' ? 'text-slate-700' : 'text-foreground/80';
+  const feedbackButtonClass =
+    variant === 'light' ? FEEDBACK_BUTTON_CLASS_LIGHT : FEEDBACK_BUTTON_CLASS_DEFAULT;
 
   const headerClasses = cn(
     'fixed top-0 left-0 right-0 z-50 border-b backdrop-blur-lg',
@@ -127,7 +141,7 @@ const Header = ({ variant = 'default', className }: HeaderProps) => {
             })}
 
             {/* Feedback CTA */}
-            <Button asChild size="sm">
+            <Button asChild variant="ghost" size="sm" className={feedbackButtonClass}>
               <a href={FEEDBACK_HREF}>
                 <MessageSquareText />
                 Feedback
@@ -232,7 +246,12 @@ const Header = ({ variant = 'default', className }: HeaderProps) => {
             })}
 
             {/* Feedback CTA */}
-            <Button asChild size="sm" className="w-full mt-2">
+            <Button
+              asChild
+              variant="ghost"
+              size="sm"
+              className={cn(feedbackButtonClass, 'w-full mt-2')}
+            >
               <a href={FEEDBACK_HREF} onClick={() => setIsMenuOpen(false)}>
                 <MessageSquareText />
                 Feedback
diff --git a/app/src/explore/control-bar-events.ts b/app/src/explore/control-bar-events.ts
index 5b1940b3..d558d3bc 100644
--- a/app/src/explore/control-bar-events.ts
+++ b/app/src/explore/control-bar-events.ts
@@ -1,8 +1,4 @@
-import type {
-  ProtspaceControlBar,
-  ProtspaceScatterplot,
-  SelectionDisabledNotificationDetail,
-} from '@protspace/core';
+import type { SelectionDisabledNotificationDetail } from '@protspace/core';
 import { notify } from '../lib/notify';
 import { getSelectionDisabledNotification } from './notifications';
 import type { DatasetController } from './dataset-controller';
@@ -15,26 +11,21 @@ interface ControlBarEventsOptions {
     listener: EventListenerOrEventListenerObject,
     options?: boolean | AddEventListenerOptions,
   ): void;
-  controlBar: ProtspaceControlBar;
   datasetController: DatasetController;
   handleExport(event: Event): Promise<void>;
   interactionController: InteractionController;
-  plotElement: ProtspaceScatterplot;
   viewController: ViewController;
 }
 
 export function bindControlBarEvents({
   addControlBarListener,
-  controlBar,
   datasetController,
   handleExport,
   interactionController,
-  plotElement,
   viewController,
 }: ControlBarEventsOptions): void {
   addControlBarListener('annotation-change', () => {
-    const nextAnnotation = controlBar.selectedAnnotation || plotElement.selectedAnnotation || '';
-    interactionController.handleAnnotationChange(nextAnnotation);
+    interactionController.handleAnnotationChange();
     viewController.handleUserAnnotationChange();
   });
 
diff --git a/app/src/explore/dataset-controller.ts b/app/src/explore/dataset-controller.ts
index 93dd8e7a..0cbc5668 100644
--- a/app/src/explore/dataset-controller.ts
+++ b/app/src/explore/dataset-controller.ts
@@ -138,11 +138,7 @@ export function createDatasetController({
       legendElement.clearForNewDataset(datasetHash, shouldClearPersistedState);
       controlBar.clearForNewDataset(datasetHash, shouldClearPersistedState);
 
-      const initialViewFallback = Object.keys(data.annotations)[0] ?? '';
-      interactionController.setLastKnownAnnotation(initialViewFallback);
-
-      const initialView = await loadData(data);
-      interactionController.setLastKnownAnnotation(initialView?.annotation ?? initialViewFallback);
+      await loadData(data);
 
       const shouldApplyEmbeddedFileSettings = settings && loadMeta.kind !== 'opfs';
       if (shouldApplyEmbeddedFileSettings) {
diff --git a/app/src/explore/interaction-controller.ts b/app/src/explore/interaction-controller.ts
index a91b1300..a0bdef21 100644
--- a/app/src/explore/interaction-controller.ts
+++ b/app/src/explore/interaction-controller.ts
@@ -6,7 +6,6 @@ import type {
   StructureErrorEventDetail,
   StructureLoadEvent,
 } from '@protspace/core';
-import type { VisualizationData } from '@protspace/utils';
 import { getProteinAnnotationIndices } from '@protspace/utils';
 import { notify } from '../lib/notify';
 import { getLegendErrorNotification } from './notifications';
@@ -16,22 +15,19 @@ interface InteractionControllerOptions {
   plotElement: ProtspaceScatterplot;
   selectedProteinElement: HTMLElement | null;
   structureViewer: ProtspaceStructureViewer;
-  clearPersistedLegendHiddenValues: (annotation: string, dataOverride?: VisualizationData) => void;
 }
 
 export interface InteractionController {
   updateLegend(): void;
   updateSelectedProteinDisplay(proteinId: string | null): void;
   getSelectedProteins(): string[];
-  setLastKnownAnnotation(annotation: string): void;
   handleSelectionChange(event: Event): void;
   handlePlotDataChange(): void;
-  handleLegendItemClick(event: Event): void;
   handleLegendError(event: Event): void;
   handleStructureLoad(event: Event): void;
   handleStructureError(event: Event): void;
   handleStructureClose(event: Event): void;
-  handleAnnotationChange(nextAnnotation: string): void;
+  handleAnnotationChange(): void;
 }
 
 export function createInteractionController({
@@ -39,11 +35,8 @@ export function createInteractionController({
   plotElement,
   selectedProteinElement,
   structureViewer,
-  clearPersistedLegendHiddenValues,
 }: InteractionControllerOptions): InteractionController {
-  let hiddenValues: string[] = [];
   let selectedProteins: string[] = [];
-  let lastKnownAnnotation = '';
 
   const updateSelectedProteinDisplay = (proteinId: string | null) => {
     if (!selectedProteinElement) {
@@ -96,9 +89,6 @@ export function createInteractionController({
     getSelectedProteins() {
       return selectedProteins;
     },
-    setLastKnownAnnotation(annotation) {
-      lastKnownAnnotation = annotation;
-    },
     handleSelectionChange(event) {
       const customEvent = event as CustomEvent<{ proteinIds?: string[] }>;
       selectedProteins = Array.isArray(customEvent.detail.proteinIds)
@@ -118,17 +108,6 @@ export function createInteractionController({
       selectedProteins = plotElement.selectedProteinIds || [];
       updateLegend();
     },
-    handleLegendItemClick(event) {
-      const customEvent = event as CustomEvent<{ value: string | null }>;
-      const valueKey = customEvent.detail.value === null ? 'null' : customEvent.detail.value;
-
-      if (hiddenValues.includes(valueKey)) {
-        hiddenValues = hiddenValues.filter((value) => value !== valueKey);
-        return;
-      }
-
-      hiddenValues = [...hiddenValues, valueKey];
-    },
     handleLegendError(event) {
       const customEvent = event as CustomEvent<LegendErrorEventDetail>;
       console.error('Legend error:', customEvent.detail);
@@ -152,15 +131,16 @@ export function createInteractionController({
       console.log('Structure viewer should now be hidden');
       updateSelectedProteinDisplay(null);
     },
-    handleAnnotationChange(nextAnnotation) {
-      if (lastKnownAnnotation && lastKnownAnnotation !== nextAnnotation) {
-        clearPersistedLegendHiddenValues(lastKnownAnnotation);
-      }
-
-      hiddenValues = [];
-      plotElement.hiddenAnnotationValues = hiddenValues;
+    handleAnnotationChange() {
+      // Synchronously clear the plot's hidden set for the newly selected
+      // annotation. The core legend owns per-annotation visibility: it persists
+      // hidden categories (saveSettings/loadSettings, keyed by datasetHash +
+      // annotation) and restores them on its own (async, Lit-driven) update
+      // cycle, which runs after this synchronous handler — so this reset is
+      // intentionally overwritten and switching away and back restores the
+      // previously hidden categories.
+      plotElement.hiddenAnnotationValues = [];
       updateLegend();
-      lastKnownAnnotation = nextAnnotation;
     },
   };
 }
diff --git a/app/src/explore/persisted-legend.ts b/app/src/explore/persisted-legend.ts
deleted file mode 100644
index 2566f1dc..00000000
--- a/app/src/explore/persisted-legend.ts
+++ /dev/null
@@ -1,66 +0,0 @@
-import type { ProtspaceScatterplot } from '@protspace/core';
-import {
-  buildStorageKey,
-  generateDatasetHash,
-  getStorageItem,
-  setStorageItem,
-  type VisualizationData,
-} from '@protspace/utils';
-
-interface PersistedLegendOptions {
-  plotElement: ProtspaceScatterplot;
-}
-
-interface PersistedLegendController {
-  clearPersistedLegendHiddenValues(annotation: string, dataOverride?: VisualizationData): void;
-}
-
-export function createPersistedLegendController({
-  plotElement,
-}: PersistedLegendOptions): PersistedLegendController {
-  const getCurrentDatasetForPersistence = (
-    dataOverride?: VisualizationData,
-  ): VisualizationData | null => {
-    if (dataOverride) {
-      return dataOverride;
-    }
-
-    const plotWithUnfilteredGetter = plotElement as ProtspaceScatterplot & {
-      getCurrentData?: (options?: {
-        includeFilteredProteinIds?: boolean;
-      }) => VisualizationData | undefined;
-    };
-
-    return (
-      plotWithUnfilteredGetter.getCurrentData?.({ includeFilteredProteinIds: false }) ??
-      plotElement.getCurrentData?.() ??
-      plotElement.data ??
-      null
-    );
-  };
-
-  return {
-    clearPersistedLegendHiddenValues(annotation, dataOverride) {
-      if (!annotation) {
-        return;
-      }
-
-      const dataset = getCurrentDatasetForPersistence(dataOverride);
-      if (!dataset) {
-        return;
-      }
-
-      const storageKey = buildStorageKey('legend', generateDatasetHash(dataset), annotation);
-      const persistedSettings = getStorageItem<Record<string, unknown> | null>(storageKey, null);
-
-      if (!persistedSettings || !Array.isArray(persistedSettings.hiddenValues)) {
-        return;
-      }
-
-      setStorageItem(storageKey, {
-        ...persistedSettings,
-        hiddenValues: [],
-      });
-    },
-  };
-}
diff --git a/app/src/explore/runtime.ts b/app/src/explore/runtime.ts
index a50c3e1d..0d35612d 100644
--- a/app/src/explore/runtime.ts
+++ b/app/src/explore/runtime.ts
@@ -21,7 +21,6 @@ import {
 } from './fasta-prep-limits';
 import { createLoadQueue } from './load-queue';
 import { createLoadingOverlayController } from './loading-overlay';
-import { createPersistedLegendController } from './persisted-legend';
 import { startInitialExploreLoad } from './startup';
 import { NOOP_CONTROLLER, type ExploreController } from './types';
 import { createViewController } from './view-controller';
@@ -217,16 +216,11 @@ export async function initializeExploreRuntime(): Promise<ExploreController> {
   });
   lifecycle.addCleanup(() => viewController.dispose());
 
-  const persistedLegendController = createPersistedLegendController({
-    plotElement,
-  });
-
   const interactionController = createInteractionController({
     legendElement,
     plotElement,
     selectedProteinElement,
     structureViewer,
-    clearPersistedLegendHiddenValues: persistedLegendController.clearPersistedLegendHiddenValues,
   });
 
   const datasetController = createDatasetController({
@@ -275,12 +269,6 @@ export async function initializeExploreRuntime(): Promise<ExploreController> {
     'data-isolation-reset',
     interactionController.updateLegend,
   );
-  addTrackedEventListener(
-    lifecycle,
-    legendElement,
-    'legend-item-click',
-    interactionController.handleLegendItemClick,
-  );
   addTrackedEventListener(
     lifecycle,
     legendElement,
@@ -321,11 +309,9 @@ export async function initializeExploreRuntime(): Promise<ExploreController> {
     addControlBarListener(type, listener, options) {
       addTrackedEventListener(lifecycle, controlBar, type, listener, options);
     },
-    controlBar,
     datasetController,
     handleExport,
     interactionController,
-    plotElement,
     viewController,
   });
 
diff --git a/app/tests/url-view-state.spec.ts b/app/tests/url-view-state.spec.ts
index c3ab6c29..2f144102 100644
--- a/app/tests/url-view-state.spec.ts
+++ b/app/tests/url-view-state.spec.ts
@@ -813,7 +813,7 @@ test.describe('URL-backed explore view state', () => {
     await expect(page).toHaveURL(/foo=1/);
   });
 
-  test('resets hidden legend state when back navigation changes annotation via URL', async ({
+  test('restores hidden legend state when back navigation returns to a previous annotation via URL', async ({
     page,
   }) => {
     await page.goto(
@@ -838,6 +838,37 @@ test.describe('URL-backed explore view state', () => {
 
     await page.goBack();
     await waitForView(page, { annotation: targetAnnotation, projection: targetProjection });
-    await expect.poll(() => isLegendItemHidden(page, firstLegendValue)).toBe(false);
+    // Per-annotation legend visibility is persisted (datasetHash + annotation), so
+    // returning to the original annotation restores the previously hidden category.
+    await expect.poll(() => isLegendItemHidden(page, firstLegendValue)).toBe(true);
+  });
+
+  test('keeps hidden legend categories when switching annotation away and back via the control bar', async ({
+    page,
+  }) => {
+    await page.goto(
+      `/explore?annotation=${encodeURIComponent(targetAnnotation)}&projection=${encodeURIComponent(targetProjection)}`,
+    );
+    await dismissTourIfPresent(page);
+    await waitForExploreDataLoad(page);
+    await waitForView(page, { annotation: targetAnnotation, projection: targetProjection });
+
+    const currentView = await getCurrentView(page);
+    const nextAnnotation = currentView.annotations.find(
+      (annotation) => annotation !== targetAnnotation,
+    );
+    expect(nextAnnotation).toBeTruthy();
+
+    const firstLegendValue = await getFirstLegendItemValue(page);
+    await clickLegendItem(page, firstLegendValue);
+    await expect.poll(() => isLegendItemHidden(page, firstLegendValue)).toBe(true);
+
+    // Switch to another annotation and back, both via the control bar (no URL navigation).
+    await selectAnnotation(page, nextAnnotation!);
+    await waitForView(page, { annotation: nextAnnotation! });
+    await selectAnnotation(page, targetAnnotation);
+    await waitForView(page, { annotation: targetAnnotation });
+
+    await expect.poll(() => isLegendItemHidden(page, firstLegendValue)).toBe(true);
   });
 });
diff --git a/packages/core/src/components/data-loader/utils/conversion.test.ts b/packages/core/src/components/data-loader/utils/conversion.test.ts
index 290b3b87..2a3c9ddd 100644
--- a/packages/core/src/components/data-loader/utils/conversion.test.ts
+++ b/packages/core/src/components/data-loader/utils/conversion.test.ts
@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { parseAnnotationValue } from './conversion';
+import { parseAnnotationValue, splitCategoricalAnnotationValues } from './conversion';
 
 describe('parseAnnotationValue', () => {
   it('parses label without pipe as full string with empty scores', () => {
@@ -166,3 +166,60 @@ describe('parseAnnotationValue', () => {
     expect(result.evidence).toBeNull();
   });
 });
+
+describe('splitCategoricalAnnotationValues', () => {
+  it('splits distinct hits on the top-level ; separator', () => {
+    expect(splitCategoricalAnnotationValues('PF00001 (7tm_1)|1.5e-10;PF00002 (Foo)|30.0')).toEqual([
+      'PF00001 (7tm_1)|1.5e-10',
+      'PF00002 (Foo)|30.0',
+    ]);
+  });
+
+  it('keeps a CATH-Gene3D name containing ";" intact as a single category', () => {
+    // Real-world shape: the name itself contains semicolons inside the parentheses.
+    expect(
+      splitCategoricalAnnotationValues(
+        'G3DSA:3.100 (Ribosomal Protein L15; Chain: K; domain 2)|45.2',
+      ),
+    ).toEqual(['G3DSA:3.100 (Ribosomal Protein L15; Chain: K; domain 2)|45.2']);
+  });
+
+  it('splits two CATH hits whose names both contain ";"', () => {
+    expect(
+      splitCategoricalAnnotationValues(
+        'G3DSA:3.100 (Ribosomal Protein L15; Chain: K; domain 2)|45.2;' +
+          'G3DSA:2.40 (Acid Proteases; Chain A)|30.0',
+      ),
+    ).toEqual([
+      'G3DSA:3.100 (Ribosomal Protein L15; Chain: K; domain 2)|45.2',
+      'G3DSA:2.40 (Acid Proteases; Chain A)|30.0',
+    ]);
+  });
+
+  it('handles nested balanced parentheses in a name', () => {
+    expect(
+      splitCategoricalAnnotationValues('G3DSA:2.60 (3-Layer(aba) Sandwich; domain 1)|12.0'),
+    ).toEqual(['G3DSA:2.60 (3-Layer(aba) Sandwich; domain 1)|12.0']);
+  });
+
+  it('still splits plain multi-value cells without parentheses', () => {
+    expect(splitCategoricalAnnotationValues('Cytoplasm;Nucleus;Membrane')).toEqual([
+      'Cytoplasm',
+      'Nucleus',
+      'Membrane',
+    ]);
+  });
+
+  it('falls back to a plain split when a name has an unbalanced "(" so distinct hits are not merged', () => {
+    // The name "YojJ-like (1" never closes its paren; depth never returns to 0, so the
+    // paren-aware scan would swallow the inter-hit ";". The fallback keeps the two hits apart.
+    expect(
+      splitCategoricalAnnotationValues('G3DSA:1.10 (YojJ-like (1)|9.0;G3DSA:3.40 (Bar)|8.0'),
+    ).toEqual(['G3DSA:1.10 (YojJ-like (1)|9.0', 'G3DSA:3.40 (Bar)|8.0']);
+  });
+
+  it('returns an empty array for missing cells', () => {
+    expect(splitCategoricalAnnotationValues(null)).toEqual([]);
+    expect(splitCategoricalAnnotationValues('')).toEqual([]);
+  });
+});
diff --git a/packages/core/src/components/data-loader/utils/conversion.ts b/packages/core/src/components/data-loader/utils/conversion.ts
index e3587502..9b03de6c 100644
--- a/packages/core/src/components/data-loader/utils/conversion.ts
+++ b/packages/core/src/components/data-loader/utils/conversion.ts
@@ -219,14 +219,73 @@ export const parseAnnotationValue = (
   return { label, scores, evidence: null };
 };
 
-function splitCategoricalAnnotationValues(rawValue: unknown): string[] {
+/**
+ * Split a categorical annotation cell on the top-level hit separator ';'.
+ *
+ * Multi-hit values are encoded as `accession (name)|score;accession2 (name2)|score`,
+ * but a name can legitimately contain ';' — e.g. CATH-Gene3D names such as
+ * "Ribosomal Protein L15; Chain: K; domain 2". A naive `split(';')` shatters one hit
+ * into bogus categories ("Chain: K", "domain 2)"). Splitting only on ';' at parenthesis
+ * depth 0 keeps each `(name)` intact while still separating distinct hits.
+ *
+ * If a name contains an unbalanced '(' so the running depth never returns to 0, fall back
+ * to a plain split so two distinct hits are not merged — at the cost of re-splitting that
+ * one rare value. Note this only catches a *net* imbalance (depth != 0 at the end): a stray
+ * '(' in one hit cancelled by a stray ')' in a later hit leaves the final depth at 0, so the
+ * inter-hit ';' (seen while depth was > 0) is silently swallowed and those two hits merge.
+ * Both are symptoms of unsanitized names; sanitizing at the source is tracked in
+ * tsenoner/protspace#56.
+ */
+function splitOnTopLevelSemicolons(value: string): string[] {
+  // Fast path: with no '(' the depth stays 0 throughout, so the paren-aware scan
+  // is byte-identical to a native split. Skip it for the common case
+  // (Kingdom/Organism/Localization cells carry no parentheses).
+  if (!value.includes('(')) {
+    return value.split(';');
+  }
+
+  // Index scan + slice: cut the string only at top-level ';' positions, avoiding the
+  // per-character allocation and code-point decoding of a `for..of` + `current += ch` build.
+  const parts: string[] = [];
+  let depth = 0;
+  let start = 0;
+
+  for (let i = 0; i < value.length; i += 1) {
+    const ch = value[i];
+    if (ch === '(') {
+      depth += 1;
+    } else if (ch === ')') {
+      if (depth > 0) depth -= 1; // clamp at 0 so a stray ')' can't go negative
+    } else if (ch === ';' && depth === 0) {
+      parts.push(value.slice(start, i));
+      start = i + 1;
+    }
+  }
+  parts.push(value.slice(start));
+
+  if (depth !== 0) {
+    return value.split(';');
+  }
+  return parts;
+}
+
+/**
+ * Split a raw categorical annotation cell into its individual hit strings.
+ *
+ * Normalizes the whole cell first (an entirely missing cell yields `[]`), splits on the
+ * top-level ';' separator via {@link splitOnTopLevelSemicolons} (paren-aware, so names
+ * containing ';' stay intact), then trims each token and drops empty or missing-value tokens.
+ *
+ * @param rawValue - the raw cell value; non-strings are normalized then stringified.
+ * @returns the trimmed, non-missing hit strings, in source order.
+ */
+export function splitCategoricalAnnotationValues(rawValue: unknown): string[] {
   // First-level: normalize the whole cell. Returns null if the entire cell is missing.
   const cellNormalized = normalizeMissingValue(rawValue);
   if (cellNormalized == null) return [];
 
-  // Split, trim, drop empty tokens, and drop tokens that normalize to missing.
-  return String(cellNormalized)
-    .split(';')
+  // Split on top-level ';' (paren-aware), trim, drop empty/missing tokens.
+  return splitOnTopLevelSemicolons(String(cellNormalized))
     .map((part) => part.trim())
     .filter((part) => part !== '' && normalizeMissingValue(part) !== null);
 }