diff --git a/extensions/src/platform-scripture-editor/src/_usj-nodes.scss b/extensions/src/platform-scripture-editor/src/_usj-nodes.scss
index 6d50fb19f28..06745e99ab1 100644
--- a/extensions/src/platform-scripture-editor/src/_usj-nodes.scss
+++ b/extensions/src/platform-scripture-editor/src/_usj-nodes.scss
@@ -6,6 +6,8 @@
    demo copy's d95907eed30 sync — the two vendored copies must not diverge on those rules).
    When re-syncing, see the "Indent compensation" comment in the gutter section below for the
    invariant usj-nodes-scss-coverage.test.ts enforces on this file and the demo copy.
+   `.psc-para-marker-selected` is this repo's own rule: the library styles that class in its
+   editor.css, which this repo does not load, and the colours here are theme tokens.
    The source's four `local()`-only Charis SIL @font-face rules are dropped. */
 
 /* stylelint-disable */
@@ -3012,6 +3014,48 @@ span.read img {
   right: calc(-1 * (var(--psc-gutter-width) - 0.5em) - var(--para-indent));
 }
 
+/* Paragraph-marker selection (paragraph-structure view). The editor puts `psc-para-marker-selected`
+   on the paragraph whose gutter marker is the selection. Selection gets a channel of its own, as in
+   adr-list-selection-on-a-dedicated-visual-channel (a 4px leading bar, never the active-text focus
+   box, which owns this element's ::after, and no pseudo-element), but diverges from that ADR in two
+   ways. It adds a row fill, which the ADR rejects for comment cards: those backgrounds carry status,
+   whereas a paragraph row's background carries none. And the bar is a box-shadow rather than a
+   logical border-inline-start, because the gutter lies outside the paragraph's box — the glyph is
+   absolutely positioned into .editor-input's padding — where no border can reach; box-shadow has no
+   logical form, hence the explicit RTL rule below. Both layers are outer box-shadows offset toward
+   inline-start by the gutter width plus the paragraph's own indent compensation; the fill layer
+   stops 4px short, which is the bar. `--foreground` is the bar token by measured contrast (>= 3:1
+   against --background and --accent in every built-in theme), pinned by
+   paragraph-marker-selection-contrast.test.ts. */
+.psc-gutter-markers .psc-para-marker-selected {
+  --psc-para-marker-selection-reach: calc(var(--psc-gutter-width) + var(--para-indent, 0px));
+  background-color: var(--accent);
+  box-shadow:
+    calc(4px - var(--psc-para-marker-selection-reach)) 0 0 0 var(--accent),
+    calc(-1 * var(--psc-para-marker-selection-reach)) 0 0 0 var(--foreground);
+}
+
+.psc-gutter-markers[dir='rtl'] .psc-para-marker-selected {
+  box-shadow:
+    calc(var(--psc-para-marker-selection-reach) - 4px) 0 0 0 var(--accent),
+    var(--psc-para-marker-selection-reach) 0 0 0 var(--foreground);
+}
+
+.psc-gutter-markers .psc-para-marker-selected > .marker:not(.verse):not(.chapter):first-child {
+  color: var(--accent-foreground);
+  font-weight: 700;
+}
+
+/* Forced colors (e.g. Windows high contrast) drop box-shadow and replace the --accent fill with the
+   system background, which would leave only the bold glyph to mark the selection. An outline in the
+   system Highlight colour survives there and, drawn around the whole paragraph box, needs no
+   direction-specific rule. */
+@media (forced-colors: active) {
+  .psc-gutter-markers .psc-para-marker-selected {
+    outline: 2px solid Highlight;
+  }
+}
+
 /* ── Active text focus box ────────────────────────────────────────────────────
    Applied via .psc-active-focus when viewOptions.hasActiveTextFocusBox is true.
    Shows an outline box around the verse range under the cursor. When used
diff --git a/extensions/src/platform-scripture-editor/src/character-marker-control/character-marker-control.component.tsx b/extensions/src/platform-scripture-editor/src/character-marker-control/character-marker-control.component.tsx
index 33ed7738812..25c4d40a128 100644
--- a/extensions/src/platform-scripture-editor/src/character-marker-control/character-marker-control.component.tsx
+++ b/extensions/src/platform-scripture-editor/src/character-marker-control/character-marker-control.component.tsx
@@ -26,6 +26,7 @@ import {
   SEARCH_PLACEHOLDER_KEY,
   SYNC_BLOCKED_KEY,
 } from './character-marker-control.const';
+import { wrapMarkerMenuItemsWithClose } from '../marker-menu.utils';
 
 export { CHARACTER_MARKER_CONTROL_STRING_KEYS } from './character-marker-control.const';
 
@@ -204,18 +205,9 @@ export function CharacterMarkerControl({
   }, [onClose]);
 
   // This is a single-select control, so picking a marker must close the menu — and closing is also
-  // what returns focus to the editor, via `onClose`. `MarkerMenu` wires `onSelect` straight to
-  // `item.action` and knows nothing about its host's open state, so the host wraps each action
-  // rather than the menu closing itself.
+  // what returns focus to the editor, via `onClose`.
   const closingMarkerMenuItems = useMemo(
-    () =>
-      markerMenuItems.map((item) => ({
-        ...item,
-        action: () => {
-          item.action();
-          closeMenu();
-        },
-      })),
+    () => wrapMarkerMenuItemsWithClose(markerMenuItems, closeMenu),
     [markerMenuItems, closeMenu],
   );
 
diff --git a/extensions/src/platform-scripture-editor/src/marker-menu.utils.test.ts b/extensions/src/platform-scripture-editor/src/marker-menu.utils.test.ts
new file mode 100644
index 00000000000..71f762b5620
--- /dev/null
+++ b/extensions/src/platform-scripture-editor/src/marker-menu.utils.test.ts
@@ -0,0 +1,47 @@
+import { describe, it, expect, vi } from 'vitest';
+import { MarkerMenuItem } from 'platform-bible-react';
+import { wrapMarkerMenuItemsWithClose } from './marker-menu.utils';
+
+function makeItem(marker: string, action = vi.fn()): MarkerMenuItem {
+  return { marker, title: `Title ${marker}`, action };
+}
+
+describe('wrapMarkerMenuItemsWithClose', () => {
+  it("runs the picked item's action, then closes the menu", () => {
+    const calls: string[] = [];
+    const items = [
+      makeItem(
+        'p',
+        vi.fn(() => calls.push('action')),
+      ),
+    ];
+
+    const [wrapped] = wrapMarkerMenuItemsWithClose(items, () => calls.push('close'));
+    wrapped.action();
+
+    expect(calls).toEqual(['action', 'close']);
+  });
+
+  it('runs only the picked item and closes once', () => {
+    const first = makeItem('p');
+    const second = makeItem('q1');
+    const close = vi.fn();
+
+    wrapMarkerMenuItemsWithClose([first, second], close)[1].action();
+
+    expect(second.action).toHaveBeenCalledTimes(1);
+    expect(first.action).not.toHaveBeenCalled();
+    expect(close).toHaveBeenCalledTimes(1);
+  });
+
+  it('keeps every other field and leaves the input items unchanged', () => {
+    const original = makeItem('s1');
+    const originalAction = original.action;
+
+    const [wrapped] = wrapMarkerMenuItemsWithClose([original], vi.fn());
+
+    expect(wrapped).toEqual({ ...original, action: expect.any(Function) });
+    expect(wrapped.action).not.toBe(originalAction);
+    expect(original.action).toBe(originalAction);
+  });
+});
diff --git a/extensions/src/platform-scripture-editor/src/marker-menu.utils.ts b/extensions/src/platform-scripture-editor/src/marker-menu.utils.ts
new file mode 100644
index 00000000000..46948d0a978
--- /dev/null
+++ b/extensions/src/platform-scripture-editor/src/marker-menu.utils.ts
@@ -0,0 +1,25 @@
+import { MarkerMenuItem } from 'platform-bible-react';
+
+/**
+ * Wraps each item's action so that picking it also closes the host's menu.
+ *
+ * A single-select marker control must close on pick, but `MarkerMenu` wires `onSelect` straight to
+ * `item.action` and knows nothing about its host's open state, so the host wraps each action rather
+ * than the menu closing itself. The item's own action runs first, then `close`.
+ *
+ * @param items The menu items to wrap
+ * @param close Closes the host's menu; runs after the picked item's action
+ * @returns New items with the same fields and wrapped actions; the input items are not modified
+ */
+export function wrapMarkerMenuItemsWithClose(
+  items: MarkerMenuItem[],
+  close: () => void,
+): MarkerMenuItem[] {
+  return items.map((item) => ({
+    ...item,
+    action: () => {
+      item.action();
+      close();
+    },
+  }));
+}
diff --git a/extensions/src/platform-scripture-editor/src/paragraph-marker-selection-contrast.test.ts b/extensions/src/platform-scripture-editor/src/paragraph-marker-selection-contrast.test.ts
new file mode 100644
index 00000000000..1599618bc58
--- /dev/null
+++ b/extensions/src/platform-scripture-editor/src/paragraph-marker-selection-contrast.test.ts
@@ -0,0 +1,95 @@
+// @vitest-environment node
+import { readFileSync } from 'fs';
+import path from 'path';
+import chroma from 'chroma-js';
+import { describe, expect, it } from 'vitest';
+
+// WCAG 2.2 non-text contrast minimum (SC 1.4.11). The selected-row bar is a UI indicator, not text.
+const MIN_NON_TEXT_CONTRAST = 3;
+// WCAG 2.2 text contrast minimum (SC 1.4.3). The selected marker glyph is text.
+const MIN_TEXT_CONTRAST = 4.5;
+
+type ThemeFile = Record<string, Record<string, { cssVariables: Record<string, string> }>>;
+
+// The built-in themes as the app loads them (generated from platform-bible-react's index.css by
+// its build-themes script). Read from disk so this extension test needs no import from that package.
+const themesPath = path.resolve(__dirname, '../../../../src/shared/data/themes.data.json');
+// JSON.parse returns `any`, which assigns to the known theme-file shape without a type assertion
+const themeFile: ThemeFile = JSON.parse(readFileSync(themesPath, 'utf-8'));
+
+/**
+ * Every theme with real variables. The file also carries `user-*` placeholder families with empty
+ * `cssVariables`; filtering on that rather than on names means a fifth real theme is swept
+ * automatically.
+ */
+const realThemes = Object.entries(themeFile).flatMap(([familyId, family]) =>
+  Object.entries(family)
+    .filter(([, definition]) => Object.keys(definition.cssVariables).length > 0)
+    .map(([themeType, definition]) => ({
+      name: familyId ? `${familyId}-${themeType}` : themeType,
+      cssVariables: definition.cssVariables,
+    })),
+);
+
+const scss = readFileSync(path.resolve(__dirname, '_usj-nodes.scss'), 'utf-8').replace(
+  /\/\*[\s\S]*?\*\//g,
+  '',
+);
+
+/** The declarations of the rule with exactly this selector, or undefined if there is none. */
+const block = (selector: string) =>
+  scss.match(
+    new RegExp(`${selector.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*\\{([^}]*)\\}`),
+  )?.[1];
+
+// `--foreground` is the bar token because it is the one that clears the minimum everywhere:
+// `--primary` and `--ring`, the obvious alternatives, each fall short in at least one built-in theme.
+describe('selected paragraph marker bar contrast', () => {
+  it('found real themes to check', () => {
+    // Guards the sweep: a filter that excluded every theme would pass every check by running none.
+    expect(realThemes.length).toBeGreaterThanOrEqual(4);
+  });
+
+  it('ties the sweep to the token the stylesheet actually paints the bar with', () => {
+    // The bar is the second (lower) box-shadow layer; the fill `--accent` layer covers all of it but
+    // the leading 4px. A change to another token there fails here instead of passing silently.
+    const bar = /box-shadow:[^;]*var\(--accent\)\s*,[^;]*var\(--foreground\)\s*;/;
+    expect(block('.psc-gutter-markers .psc-para-marker-selected')).toMatch(bar);
+    expect(block(".psc-gutter-markers[dir='rtl'] .psc-para-marker-selected")).toMatch(bar);
+  });
+
+  // The bar sits over the fill's neighbour: the editor surface (`--background`) at its outer edge
+  // and the row fill (`--accent`) at its inner edge. One theme passing proves nothing about the others.
+  realThemes.forEach(({ name, cssVariables }) => {
+    (['background', 'accent'] as const).forEach((surface) => {
+      it(`clears ${MIN_NON_TEXT_CONTRAST}:1 against --${surface} in ${name}`, () => {
+        const contrast = chroma.contrast(
+          chroma(cssVariables.foreground),
+          chroma(cssVariables[surface]),
+        );
+        expect(contrast).toBeGreaterThanOrEqual(MIN_NON_TEXT_CONTRAST);
+      });
+    });
+  });
+});
+
+describe('selected paragraph marker glyph contrast', () => {
+  it('ties the sweep to the token the stylesheet actually paints the glyph with', () => {
+    expect(
+      block(
+        '.psc-gutter-markers .psc-para-marker-selected > .marker:not(.verse):not(.chapter):first-child',
+      ),
+    ).toMatch(/(?:^|[\s;])color:\s*var\(--accent-foreground\)\s*;/);
+  });
+
+  // The glyph sits on the row fill (`--accent`).
+  realThemes.forEach(({ name, cssVariables }) => {
+    it(`clears ${MIN_TEXT_CONTRAST}:1 against --accent in ${name}`, () => {
+      const contrast = chroma.contrast(
+        chroma(cssVariables['accent-foreground']),
+        chroma(cssVariables.accent),
+      );
+      expect(contrast).toBeGreaterThanOrEqual(MIN_TEXT_CONTRAST);
+    });
+  });
+});
diff --git a/extensions/src/platform-scripture-editor/src/paragraph-style-trigger.component.stories.tsx b/extensions/src/platform-scripture-editor/src/paragraph-style-trigger.component.stories.tsx
index 1f5520bef3d..a421b7610f7 100644
--- a/extensions/src/platform-scripture-editor/src/paragraph-style-trigger.component.stories.tsx
+++ b/extensions/src/platform-scripture-editor/src/paragraph-style-trigger.component.stories.tsx
@@ -1,11 +1,12 @@
 import type { Meta, StoryObj } from '@storybook/react-webpack5';
 import {
+  Button,
   MARKER_MENU_STRING_KEYS,
   SHRINK_STEP,
   ShrinkStepOverride,
   type MarkerMenuItem,
 } from 'platform-bible-react';
-import type { ComponentProps, ReactNode } from 'react';
+import { useRef, useState, type ComponentProps, type ReactNode } from 'react';
 import { getLocalizedStrings } from '../../../../.storybook/localization.utils';
 import {
   ParagraphStyleTrigger,
@@ -25,7 +26,8 @@ import {
  * `ShrinkStepOverride` so every step is reachable at any browser width.
  *
  * **Try it**: click the trigger to open the marker menu, and hover the disabled story to see why
- * the paragraph style cannot be changed.
+ * the paragraph style cannot be changed. The editor-request story opens the menu the way Enter or
+ * Alt+Down on a selected paragraph marker does, without a click on the trigger.
  */
 const meta: Meta<typeof ParagraphStyleTrigger> = {
   title: 'Bundled Extensions/platform-scripture-editor/ParagraphStyleTrigger',
@@ -83,6 +85,8 @@ type TriggerArgs = ComponentProps<typeof ParagraphStyleTrigger>;
 
 /** Renders the trigger with the story's args, the shared menu items, and the shared strings. */
 function Trigger({ blockMarker, isStructureProtected = false, styleName }: Partial<TriggerArgs>) {
+  // The web view owns this state in the app; each story instance keeps its own so clicking opens it.
+  const [isMenuOpen, setIsMenuOpen] = useState(false);
   return (
     <ParagraphStyleTrigger
       blockMarker={blockMarker}
@@ -90,10 +94,52 @@ function Trigger({ blockMarker, isStructureProtected = false, styleName }: Parti
       localizedStrings={localizedStrings}
       markerMenuItems={markerMenuItems}
       styleName={styleName}
+      isMenuOpen={isMenuOpen}
+      onMenuOpenChange={setIsMenuOpen}
+      onReturnFocusToEditor={() => {}}
     />
   );
 }
 
+/**
+ * Renders the trigger beside a stand-in for the editor: a button that opens the menu through the
+ * controlled `isMenuOpen`, as the web view does when the editor's `onParaMarkerMenuRequest` fires,
+ * and a text box that takes focus back whenever the menu closes normally.
+ */
+function EditorRequestTrigger({
+  blockMarker,
+  isStructureProtected = false,
+  styleName,
+}: Partial<TriggerArgs>) {
+  const [isMenuOpen, setIsMenuOpen] = useState(false);
+  // The ref needs to start out with null for it to work as an element ref
+  // eslint-disable-next-line no-null/no-null
+  const editorRef = useRef<HTMLTextAreaElement>(null);
+  return (
+    <div className="tw:flex tw:flex-col tw:items-start tw:gap-2">
+      <ParagraphStyleTrigger
+        blockMarker={blockMarker}
+        isStructureProtected={isStructureProtected}
+        localizedStrings={localizedStrings}
+        markerMenuItems={markerMenuItems}
+        styleName={styleName}
+        isMenuOpen={isMenuOpen}
+        onMenuOpenChange={setIsMenuOpen}
+        onReturnFocusToEditor={() => editorRef.current?.focus()}
+      />
+      <textarea
+        ref={editorRef}
+        aria-label="Stand-in editor"
+        className="tw:w-56 tw:rounded-sm tw:border tw:p-1 tw:text-sm"
+        defaultValue="Focus returns here when the menu closes."
+      />
+      <Button size="sm" variant="secondary" onClick={() => setIsMenuOpen(true)}>
+        Open from the editor
+      </Button>
+    </div>
+  );
+}
+
 /**
  * Stands in for the toolbar's start zone: a bounded box that clips its overflow, which is what the
  * trigger's width floor and the label's ellipsis are negotiating against.
@@ -163,6 +209,15 @@ export const MarkerWidthsAtMinimum: Story = {
   ),
 };
 
+/**
+ * The menu opened by the editor rather than by a click on the trigger, as happens on Enter or
+ * Alt+Down with a paragraph marker selected. Picking an item or pressing Escape returns focus to
+ * the stand-in editor; with structure protected, the request is ignored.
+ */
+export const OpenedFromTheEditor: Story = {
+  render: (args) => <EditorRequestTrigger {...args} />,
+};
+
 /**
  * Structure is protected, so the paragraph style cannot be changed: the button is disabled and
  * hovering it explains why.
diff --git a/extensions/src/platform-scripture-editor/src/paragraph-style-trigger.component.test.tsx b/extensions/src/platform-scripture-editor/src/paragraph-style-trigger.component.test.tsx
index 369ae26a9e1..5023d53fb25 100644
--- a/extensions/src/platform-scripture-editor/src/paragraph-style-trigger.component.test.tsx
+++ b/extensions/src/platform-scripture-editor/src/paragraph-style-trigger.component.test.tsx
@@ -1,8 +1,9 @@
 // @vitest-environment jsdom
-import { render, screen } from '@testing-library/react';
+import { act, fireEvent, render, screen, waitFor } from '@testing-library/react';
 import '@testing-library/jest-dom';
-import { SHRINK_STEP, ShrinkStepOverride } from 'platform-bible-react';
-import { beforeAll, describe, expect, it } from 'vitest';
+import { SHRINK_STEP, ShrinkStepOverride, type MarkerMenuItem } from 'platform-bible-react';
+import { useState } from 'react';
+import { beforeAll, describe, expect, it, vi } from 'vitest';
 import { ParagraphStyleTrigger } from './paragraph-style-trigger.component';
 
 // jsdom doesn't ship ResizeObserver. Radix's Popper positioning, used by the popover and by the
@@ -28,6 +29,8 @@ beforeAll(() => {
   if (typeof globalThis.ResizeObserver === 'undefined') {
     globalThis.ResizeObserver = NoopResizeObserver;
   }
+  // cmdk scrolls the highlighted row into view when the menu opens; jsdom does not implement it.
+  if (!Element.prototype.scrollIntoView) Element.prototype.scrollIntoView = () => {};
 });
 
 function renderTrigger(shrinkStep?: number) {
@@ -38,6 +41,9 @@ function renderTrigger(shrinkStep?: number) {
       isStructureProtected={false}
       markerMenuItems={[]}
       localizedStrings={{}}
+      isMenuOpen={false}
+      onMenuOpenChange={() => {}}
+      onReturnFocusToEditor={() => {}}
     />
   );
   return render(
@@ -135,6 +141,9 @@ describe('ParagraphStyleTrigger', () => {
           isStructureProtected={false}
           markerMenuItems={[]}
           localizedStrings={{}}
+          isMenuOpen={false}
+          onMenuOpenChange={() => {}}
+          onReturnFocusToEditor={() => {}}
         />,
       );
 
@@ -142,3 +151,213 @@ describe('ParagraphStyleTrigger', () => {
     });
   });
 });
+
+const PARAGRAPH_ITEM_ACTION = vi.fn();
+const MENU_ITEMS: MarkerMenuItem[] = [
+  { marker: 'p', title: 'Paragraph', action: () => PARAGRAPH_ITEM_ACTION() },
+  { marker: 'q1', title: 'Poetic Line Level 1', action: () => {} },
+];
+
+/**
+ * Plays the web view's part: holds whether the menu is open, and offers a stand-in for the editor's
+ * `onParaMarkerMenuRequest` so a test can open the menu the way Enter on a selected marker does.
+ */
+function MenuHarness({
+  onReturnFocusToEditor,
+  isStructureProtected = false,
+}: {
+  onReturnFocusToEditor: () => void;
+  isStructureProtected?: boolean;
+}) {
+  const [isMenuOpen, setIsMenuOpen] = useState(false);
+  return (
+    <>
+      <button type="button" onClick={() => setIsMenuOpen(true)}>
+        Editor asks for the menu
+      </button>
+      <button type="button">Somewhere else</button>
+      <ParagraphStyleTrigger
+        blockMarker="p"
+        styleName="Paragraph"
+        isStructureProtected={isStructureProtected}
+        markerMenuItems={MENU_ITEMS}
+        localizedStrings={{}}
+        isMenuOpen={isMenuOpen}
+        onMenuOpenChange={setIsMenuOpen}
+        onReturnFocusToEditor={onReturnFocusToEditor}
+      />
+    </>
+  );
+}
+
+const TRIGGER_NAME = '%webView_platformScriptureEditor_paragraphSelection_ariaLabel%';
+const queryMenu = () => screen.queryByRole('dialog');
+const pressEscape = () =>
+  fireEvent.keyDown(document.activeElement ?? document.body, { key: 'Escape' });
+/** Radix arms its outside-pointer listener, and runs its unmount auto-focus, on zero-delay timers. */
+const flushZeroDelayTimers = () =>
+  act(async () => {
+    await new Promise((resolve) => {
+      setTimeout(resolve, 0);
+    });
+  });
+
+describe('ParagraphStyleTrigger menu', () => {
+  it('opens when the editor asks for it', async () => {
+    render(<MenuHarness onReturnFocusToEditor={vi.fn()} />);
+
+    fireEvent.click(screen.getByRole('button', { name: 'Editor asks for the menu' }));
+
+    expect(queryMenu()).toBeInTheDocument();
+    // Usable by keyboard alone the instant it opens, same as the character-marker menu beside it.
+    await waitFor(() => expect(screen.getByRole('combobox')).toHaveFocus());
+  });
+
+  it('stays closed when the editor asks while the structure is protected', () => {
+    render(<MenuHarness onReturnFocusToEditor={vi.fn()} isStructureProtected />);
+
+    fireEvent.click(screen.getByRole('button', { name: 'Editor asks for the menu' }));
+
+    expect(queryMenu()).not.toBeInTheDocument();
+  });
+
+  it('closes and returns focus to the editor when an item is picked', async () => {
+    const onReturnFocusToEditor = vi.fn();
+    PARAGRAPH_ITEM_ACTION.mockClear();
+    render(<MenuHarness onReturnFocusToEditor={onReturnFocusToEditor} />);
+    fireEvent.click(screen.getByRole('button', { name: 'Editor asks for the menu' }));
+
+    fireEvent.click(screen.getByRole('option', { name: /Paragraph/ }));
+
+    expect(PARAGRAPH_ITEM_ACTION).toHaveBeenCalledTimes(1);
+    await waitFor(() => expect(queryMenu()).not.toBeInTheDocument());
+    await waitFor(() => expect(onReturnFocusToEditor).toHaveBeenCalledTimes(1));
+    expect(screen.getByRole('button', { name: TRIGGER_NAME })).not.toHaveFocus();
+  });
+
+  it('closes and returns focus to the editor when an item is picked with Enter', async () => {
+    const onReturnFocusToEditor = vi.fn();
+    PARAGRAPH_ITEM_ACTION.mockClear();
+    render(<MenuHarness onReturnFocusToEditor={onReturnFocusToEditor} />);
+    fireEvent.click(screen.getByRole('button', { name: 'Editor asks for the menu' }));
+    const search = screen.getByRole('combobox');
+    await waitFor(() => expect(search).toHaveFocus());
+    // cmdk highlights the first row on open, which is the one Enter picks.
+    expect(screen.getByRole('option', { name: /Paragraph/ })).toHaveAttribute(
+      'aria-selected',
+      'true',
+    );
+
+    fireEvent.keyDown(search, { key: 'Enter' });
+
+    expect(PARAGRAPH_ITEM_ACTION).toHaveBeenCalledTimes(1);
+    await waitFor(() => expect(queryMenu()).not.toBeInTheDocument());
+    await waitFor(() => expect(onReturnFocusToEditor).toHaveBeenCalledTimes(1));
+    expect(screen.getByRole('button', { name: TRIGGER_NAME })).not.toHaveFocus();
+  });
+
+  it('closes on a pick from a menu the toolbar button opened, too', async () => {
+    const onReturnFocusToEditor = vi.fn();
+    render(<MenuHarness onReturnFocusToEditor={onReturnFocusToEditor} />);
+    fireEvent.click(screen.getByRole('button', { name: TRIGGER_NAME }));
+    expect(queryMenu()).toBeInTheDocument();
+
+    fireEvent.click(screen.getByRole('option', { name: /Poetic Line Level 1/ }));
+
+    await waitFor(() => expect(queryMenu()).not.toBeInTheDocument());
+    await waitFor(() => expect(onReturnFocusToEditor).toHaveBeenCalledTimes(1));
+  });
+
+  it('returns focus to the editor, not the button, when Escape dismisses the menu', async () => {
+    // Same as the character-marker control beside it: the toolbar control is a way to act on the
+    // text, so dismissing it puts the user back in the text.
+    const onReturnFocusToEditor = vi.fn();
+    render(<MenuHarness onReturnFocusToEditor={onReturnFocusToEditor} />);
+    const trigger = screen.getByRole('button', { name: TRIGGER_NAME });
+    fireEvent.click(trigger);
+
+    pressEscape();
+
+    await waitFor(() => expect(onReturnFocusToEditor).toHaveBeenCalledTimes(1));
+    expect(queryMenu()).not.toBeInTheDocument();
+    expect(trigger).not.toHaveFocus();
+  });
+
+  it('returns focus to the editor when Escape dismisses a menu the editor opened', async () => {
+    const onReturnFocusToEditor = vi.fn();
+    render(<MenuHarness onReturnFocusToEditor={onReturnFocusToEditor} />);
+    fireEvent.click(screen.getByRole('button', { name: 'Editor asks for the menu' }));
+    await waitFor(() => expect(screen.getByRole('combobox')).toHaveFocus());
+
+    pressEscape();
+
+    await waitFor(() => expect(queryMenu()).not.toBeInTheDocument());
+    await waitFor(() => expect(onReturnFocusToEditor).toHaveBeenCalledTimes(1));
+  });
+
+  it('returns focus to the editor when structure protection turns on while the menu is open', async () => {
+    // The menu closes because it stopped being available, not because the user went elsewhere, so
+    // focus must not be left in a menu that no longer exists.
+    const onReturnFocusToEditor = vi.fn();
+    const { rerender } = render(<MenuHarness onReturnFocusToEditor={onReturnFocusToEditor} />);
+    fireEvent.click(screen.getByRole('button', { name: 'Editor asks for the menu' }));
+    await waitFor(() => expect(screen.getByRole('combobox')).toHaveFocus());
+
+    rerender(<MenuHarness onReturnFocusToEditor={onReturnFocusToEditor} isStructureProtected />);
+
+    await waitFor(() => expect(queryMenu()).not.toBeInTheDocument());
+    await flushZeroDelayTimers();
+    expect(onReturnFocusToEditor).toHaveBeenCalledTimes(1);
+  });
+
+  it('leaves focus where the user put it when the menu closes because they interacted outside it', async () => {
+    const onReturnFocusToEditor = vi.fn();
+    render(<MenuHarness onReturnFocusToEditor={onReturnFocusToEditor} />);
+    fireEvent.click(screen.getByRole('button', { name: 'Editor asks for the menu' }));
+    expect(queryMenu()).toBeInTheDocument();
+    await flushZeroDelayTimers();
+
+    fireEvent.pointerDown(screen.getByRole('button', { name: 'Somewhere else' }));
+
+    await waitFor(() => expect(queryMenu()).not.toBeInTheDocument());
+    await flushZeroDelayTimers();
+    expect(onReturnFocusToEditor).not.toHaveBeenCalled();
+  });
+
+  it('returns focus to the editor when it is closed by clicking the trigger again', async () => {
+    // Radix reports a pointer-down on the trigger itself as an outside interaction, which would
+    // otherwise strand focus on the button instead of returning it to the editor.
+    const onReturnFocusToEditor = vi.fn();
+    render(<MenuHarness onReturnFocusToEditor={onReturnFocusToEditor} />);
+    const trigger = screen.getByRole('button', { name: TRIGGER_NAME });
+    fireEvent.click(trigger);
+    expect(queryMenu()).toBeInTheDocument();
+    await flushZeroDelayTimers();
+
+    fireEvent.pointerDown(trigger);
+    fireEvent.click(trigger);
+
+    await waitFor(() => expect(queryMenu()).not.toBeInTheDocument());
+    await flushZeroDelayTimers();
+    expect(onReturnFocusToEditor).toHaveBeenCalledTimes(1);
+  });
+
+  it('refocuses the editor again on the next close after an outside interaction', async () => {
+    // The outside-interaction flag belongs to one opening; a stale flag would strand focus on the
+    // next Escape.
+    const onReturnFocusToEditor = vi.fn();
+    render(<MenuHarness onReturnFocusToEditor={onReturnFocusToEditor} />);
+    const askButton = screen.getByRole('button', { name: 'Editor asks for the menu' });
+    fireEvent.click(askButton);
+    await flushZeroDelayTimers();
+    fireEvent.pointerDown(screen.getByRole('button', { name: 'Somewhere else' }));
+    await waitFor(() => expect(queryMenu()).not.toBeInTheDocument());
+    await flushZeroDelayTimers();
+
+    fireEvent.click(askButton);
+    expect(queryMenu()).toBeInTheDocument();
+    pressEscape();
+
+    await waitFor(() => expect(onReturnFocusToEditor).toHaveBeenCalledTimes(1));
+  });
+});
diff --git a/extensions/src/platform-scripture-editor/src/paragraph-style-trigger.component.tsx b/extensions/src/platform-scripture-editor/src/paragraph-style-trigger.component.tsx
index 796542a837d..2868754e865 100644
--- a/extensions/src/platform-scripture-editor/src/paragraph-style-trigger.component.tsx
+++ b/extensions/src/platform-scripture-editor/src/paragraph-style-trigger.component.tsx
@@ -11,6 +11,8 @@ import {
   SHRINK_STEP,
   useShrinkStepValue,
 } from 'platform-bible-react';
+import { useEffect, useMemo, useRef, type ElementRef } from 'react';
+import { wrapMarkerMenuItemsWithClose } from './marker-menu.utils';
 import { ParagraphStyleLabel } from './paragraph-style-label.component';
 
 const ARIA_LABEL_KEY = '%webView_platformScriptureEditor_paragraphSelection_ariaLabel%';
@@ -59,11 +61,31 @@ export type ParagraphStyleTriggerProps = {
   localizedStrings: MarkerMenuLocalizedStrings & {
     [key in ParagraphStyleTriggerStringKey]?: string;
   };
+  /**
+   * Whether the menu is open. Controlled by the caller so the editor can open it from the keyboard
+   * (Enter or Alt+Down on a selected paragraph marker).
+   */
+  isMenuOpen: boolean;
+  /**
+   * Called with `true` when this button opens the menu, and with `false` when the menu closes —
+   * including right after an item is picked, since this is a single-select control.
+   */
+  onMenuOpenChange: (isOpen: boolean) => void;
+  /**
+   * Puts keyboard focus back in the editor. Called as the menu closes, in place of Radix's return
+   * to this button, so the user is back in the text — and a selected paragraph marker, which the
+   * editor keeps while focus is in the menu, is live again for the next key. Not called when the
+   * menu closed because the user clicked or focused something else: focus belongs where they put
+   * it.
+   */
+  onReturnFocusToEditor: () => void;
 };
 
 /**
  * The toolbar's paragraph-style control: a button showing the marker and style name of the block
- * the cursor is in, which opens the paragraph marker menu.
+ * the cursor is in — or of the paragraph whose marker is selected — which opens the paragraph
+ * marker menu. The menu is controlled by the caller so the editor can open it from the keyboard;
+ * picking an item closes it, and closing returns focus to the editor.
  *
  * A component rather than inline JSX in the web view because it reads `ShrinkStepContext`, which
  * `TabToolbarContainer` publishes. `PlatformScriptureEditor` _renders_ the `TabToolbar`, so a hook
@@ -76,6 +98,9 @@ export function ParagraphStyleTrigger({
   isStructureProtected,
   markerMenuItems,
   localizedStrings,
+  isMenuOpen,
+  onMenuOpenChange,
+  onReturnFocusToEditor,
 }: ParagraphStyleTriggerProps) {
   const shrinkStep = useShrinkStepValue();
   // Once the style name has been dropped the marker is the whole label, and a marker is a code with
@@ -99,6 +124,31 @@ export function ParagraphStyleTrigger({
   const isFloored = shrinkStep >= SHRINK_STEP.MINIMUM;
   const widthFloor = isFloored ? 'tw:min-w-min' : 'tw:min-w-0';
 
+  // Set by an outside interaction and read as the menu closes; each opening starts clear.
+  const wasClosedByOutsideInteractionRef = useRef(false);
+  useEffect(() => {
+    if (isMenuOpen) wasClosedByOutsideInteractionRef.current = false;
+  }, [isMenuOpen]);
+
+  // Radix reports a pointer-down on the trigger itself as an outside interaction, since it lands
+  // outside the popover content. Read against this ref so closing that way still counts as a normal
+  // close and returns focus to the editor, rather than stranding it on the button.
+  // The ref needs to start out with null for it to work as an element ref
+  // eslint-disable-next-line no-null/no-null
+  const triggerRef = useRef<ElementRef<typeof Button>>(null);
+
+  // This is a single-select control, so picking a marker must close the menu.
+  const closingMarkerMenuItems = useMemo(
+    () => wrapMarkerMenuItemsWithClose(markerMenuItems, () => onMenuOpenChange(false)),
+    [markerMenuItems, onMenuOpenChange],
+  );
+
+  const handleCloseAutoFocus = (event: Event) => {
+    if (wasClosedByOutsideInteractionRef.current) return;
+    event.preventDefault();
+    onReturnFocusToEditor();
+  };
+
   // Truthy, not just defined: an empty marker has nothing to put in the label, so the trigger would
   // render an empty box followed by a dangling " - " and the generic fallback description. No marker
   // and no block are the same state to a user, so they read the same way.
@@ -114,9 +164,15 @@ export function ParagraphStyleTrigger({
       // narrows.
       className={widthFloor}
     >
-      <Popover>
+      <Popover
+        // Structure protection disables the button, so it must also keep an editor request from
+        // opening the menu around it.
+        open={isMenuOpen && !isStructureProtected}
+        onOpenChange={onMenuOpenChange}
+      >
         <PopoverTrigger asChild>
           <Button
+            ref={triggerRef}
             // `tw:max-w-full` is what keeps the label ellipsising instead of the button being cut
             // off mid-border. The wrapper around this is a block box, so the button is not a flex
             // item of it and the `shrink-0` in shadcn's button base cannot be shrunk past — the
@@ -151,10 +207,20 @@ export function ParagraphStyleTrigger({
             it, including the ellipsis each row had correctly truncated to. The rows were degrading
             properly into space nobody could see. Radix measures the room actually available and
             publishes it, so cap against that and let the menu narrow instead. */}
-        <PopoverContent className="tw:w-96 tw:max-w-(--radix-popover-content-available-width) tw:p-0">
+        <PopoverContent
+          className="tw:w-96 tw:max-w-(--radix-popover-content-available-width) tw:p-0"
+          onInteractOutside={(event) => {
+            // Clicking the trigger again to close is a normal close, not an outside interaction:
+            // Radix only calls this because the pointer-down lands outside the popover CONTENT, and
+            // the trigger is outside it too.
+            if (event.target instanceof Node && triggerRef.current?.contains(event.target)) return;
+            wasClosedByOutsideInteractionRef.current = true;
+          }}
+          onCloseAutoFocus={handleCloseAutoFocus}
+        >
           <MarkerMenu
             localizedStrings={localizedStrings}
-            markerMenuItems={markerMenuItems}
+            markerMenuItems={closingMarkerMenuItems}
             searchPlaceholder={localizedStrings[SEARCH_PLACEHOLDER_KEY]}
           />
         </PopoverContent>
diff --git a/extensions/src/platform-scripture-editor/src/platform-scripture-editor.utils.test.ts b/extensions/src/platform-scripture-editor/src/platform-scripture-editor.utils.test.ts
index 9e41790ddba..5802908dc60 100644
--- a/extensions/src/platform-scripture-editor/src/platform-scripture-editor.utils.test.ts
+++ b/extensions/src/platform-scripture-editor/src/platform-scripture-editor.utils.test.ts
@@ -4,7 +4,7 @@ import type PapiBackend from '@papi/backend';
 import { newPlatformError, UsjTextContentLocation } from 'platform-bible-utils';
 import type { SavedWebViewDefinition } from '@papi/core';
 import { MutableRefObject } from 'react';
-import type { EditorRef } from '@eten-tech-foundation/platform-editor';
+import type { EditorRef, SelectionRange } from '@eten-tech-foundation/platform-editor';
 import { USJ_TYPE, USJ_VERSION, type Usj } from '@eten-tech-foundation/scripture-utilities';
 import {
   convertScriptureRangeToEditorRange,
@@ -44,6 +44,7 @@ import {
   selectableParagraphMarkers,
   PROGRAMMATICALLY_APPLIED_PARAGRAPH_MARKERS,
 } from './platform-scripture-editor.utils';
+import { restoreSelectionIfLost } from './platform-scripture-editor.web-view.utils';
 
 /** Build a mock editor ref exposing spies for the methods the generators call. */
 function makeMockEditorRef() {
@@ -2828,6 +2829,57 @@ describe('generateParagraphMenuListItems', () => {
     expect(restoreSelection).not.toHaveBeenCalled();
     expect(formatPara).not.toHaveBeenCalled();
   });
+
+  // One position language (host Standard-View-Invariants §6): a selected paragraph marker is a
+  // node selection with no offsets, so a retag from it must reach the editor as `formatPara` alone.
+  // The host never turns the selection into a position by restoring a caret over it. Wires the real
+  // restore the web view passes in, rather than a spy, so a restore that stops honoring the marker
+  // selection fails here.
+  describe('with a paragraph marker selected', () => {
+    const lastFocusOutSelection: SelectionRange = {
+      start: { jsonPath: '$.content[2].content[0]', offset: 7 },
+    };
+
+    function makeEditorWithSelectionState(selectedParaMarker: string | undefined) {
+      const formatPara = vi.fn();
+      const setSelection = vi.fn();
+      const editor = {
+        formatPara,
+        setSelection,
+        // A USJ selection is a text range, so it reports nothing while a marker is selected — and
+        // nothing after a popover blur nulled the caret.
+        getSelection: vi.fn((): SelectionRange | undefined => undefined),
+        getSelectedParaMarker: vi.fn((): string | undefined => selectedParaMarker),
+      };
+      // Mock literal cannot satisfy the full EditorRef interface — cast for test isolation.
+      // eslint-disable-next-line no-type-assertion/no-type-assertion
+      const ref = { current: editor } as unknown as MutableRefObject<EditorRef | null>;
+      const items = generateParagraphMenuListItems(ref, {}, false, vi.fn(), () =>
+        restoreSelectionIfLost(ref.current, lastFocusOutSelection),
+      );
+      return { items, formatPara, setSelection };
+    }
+
+    it('restores the lost caret when no marker is selected (control)', () => {
+      const { items, formatPara, setSelection } = makeEditorWithSelectionState(undefined);
+
+      items[0].action?.();
+
+      expect(setSelection).toHaveBeenCalledWith(lastFocusOutSelection);
+      expect(formatPara).toHaveBeenCalledWith(items[0].marker);
+    });
+
+    it('retags through formatPara without ever setting a selection position', () => {
+      const { items, formatPara, setSelection } = makeEditorWithSelectionState('li2');
+      const item = items.find((menuItem) => menuItem.marker === 'q1');
+
+      item?.action?.();
+
+      expect(formatPara).toHaveBeenCalledTimes(1);
+      expect(formatPara).toHaveBeenCalledWith('q1');
+      expect(setSelection).not.toHaveBeenCalled();
+    });
+  });
 });
 
 describe('selectableParagraphMarkers', () => {
diff --git a/extensions/src/platform-scripture-editor/src/platform-scripture-editor.web-view.tsx b/extensions/src/platform-scripture-editor/src/platform-scripture-editor.web-view.tsx
index 4bb2fbad0b3..9d5ceeeb312 100644
--- a/extensions/src/platform-scripture-editor/src/platform-scripture-editor.web-view.tsx
+++ b/extensions/src/platform-scripture-editor/src/platform-scripture-editor.web-view.tsx
@@ -121,6 +121,7 @@ import {
   PARAGRAPH_STYLE_TRIGGER_STRING_KEYS,
 } from './paragraph-style-trigger.component';
 import { useMarkerSettleDelay } from './use-marker-settle-delay.hook';
+import { useParagraphMenuOpenState } from './use-paragraph-menu-open-state.hook';
 import { useStructureProtectionState } from './use-structure-protection-state.hook';
 import { EmptyChapterView, EMPTY_CHAPTER_VIEW_STRING_KEYS } from './empty-chapter-view.component';
 import {
@@ -191,6 +192,7 @@ import {
   resolveEditingSessionActivity,
   resolveFootnotesPaneAutoVisibility,
   restoreSelectionIfLost,
+  returnFocusToEditor,
   shouldSpaceCommitNoteMarker,
   STALE_NOTE_EDITING_SESSION_MS,
 } from './platform-scripture-editor.web-view.utils';
@@ -1380,8 +1382,9 @@ globalThis.webViewComponent = function PlatformScriptureEditor({
   );
 
   // Opening the paragraph switcher's Radix popover takes focus off `.editor-input`, where Lexical's
-  // blur processing can null the selection — and `formatPara` needs one, so the retag would refuse.
-  // The `\` and Enter palettes restore it the same way before they apply.
+  // blur processing can null a caret selection — and `formatPara` needs a selection, so the retag
+  // would refuse. A selected paragraph marker survives the blur and is left as it is. The `\` and
+  // Enter palettes restore the same way before they apply.
   const restoreEditorSelection = useCallback(() => {
     restoreSelectionIfLost(editorRef.current, lastFocusOutSelectionRef.current);
   }, []);
@@ -1398,6 +1401,26 @@ globalThis.webViewComponent = function PlatformScriptureEditor({
     [localizedStrings, isStructureProtected, notifyStructureProtected, restoreEditorSelection],
   );
 
+  const {
+    isMenuOpen: isParagraphMenuOpen,
+    setIsMenuOpen: setIsParagraphMenuOpen,
+    requestMenuFromEditor: handleParagraphMarkerMenuRequest,
+  } = useParagraphMenuOpenState({
+    isReadOnly: isReadOnlyEffective,
+    isStructureProtected,
+    hasBlockMarker: !!blockMarker,
+    notifyStructureProtected,
+  });
+
+  // The editor keeps a selected paragraph marker while focus is in the paragraph menu; focusing it
+  // again makes that selection live for the next key. Opening the popover can also null a caret
+  // selection the same way the paragraph switcher does above, so the restore has to run before the
+  // focus, not just a plain `editorRef.current?.focus()`.
+  const restoreCaretAndFocusEditor = useCallback(
+    () => returnFocusToEditor(editorRef.current, lastFocusOutSelectionRef.current),
+    [],
+  );
+
   const insertCommentAtCurrentSelection = useCallback(() => {
     const selection = currentSelectionRef.current;
 
@@ -3763,6 +3786,7 @@ globalThis.webViewComponent = function PlatformScriptureEditor({
               logger={logger}
               onUsjChange={isReadOnlyEffective ? undefined : handleEditorialUsjChange}
               onSelectionChange={handleSelectionChange}
+              onParaMarkerMenuRequest={handleParagraphMarkerMenuRequest}
               onStateChange={(state) => {
                 setCanUndo(state.canUndo);
                 setCanRedo(state.canRedo);
@@ -3932,6 +3956,9 @@ globalThis.webViewComponent = function PlatformScriptureEditor({
                   isStructureProtected={isStructureProtected}
                   markerMenuItems={paragraphSwitcherMenuItems}
                   localizedStrings={localizedStrings}
+                  isMenuOpen={isParagraphMenuOpen}
+                  onMenuOpenChange={setIsParagraphMenuOpen}
+                  onReturnFocusToEditor={restoreCaretAndFocusEditor}
                 />
               </>
             )}
diff --git a/extensions/src/platform-scripture-editor/src/platform-scripture-editor.web-view.utils.test.ts b/extensions/src/platform-scripture-editor/src/platform-scripture-editor.web-view.utils.test.ts
index 7b98c3146a4..d23f1c1938e 100644
--- a/extensions/src/platform-scripture-editor/src/platform-scripture-editor.web-view.utils.test.ts
+++ b/extensions/src/platform-scripture-editor/src/platform-scripture-editor.web-view.utils.test.ts
@@ -15,6 +15,7 @@ import {
   resolveEditingSessionActivity,
   resolveFootnotesPaneAutoVisibility,
   restoreSelectionIfLost,
+  returnFocusToEditor,
   shouldSpaceCommitNoteMarker,
   STALE_NOTE_EDITING_SESSION_MS,
   type FootnotesPaneAutoVisibilityInput,
@@ -319,17 +320,20 @@ describe('resolveFootnotesPaneAutoVisibility', () => {
   });
 });
 
-describe('restoreSelectionIfLost', () => {
-  const snapshot: SelectionRange = { start: { jsonPath: '$.content[0].content[1]', offset: 4 } };
+/** The caret position a focus-out captured, for the selection-restoring helpers below. */
+const snapshot: SelectionRange = { start: { jsonPath: '$.content[0].content[1]', offset: 4 } };
 
-  /** Editor stub exposing only the two selection methods the helper consults. */
-  function makeEditor(liveSelection: SelectionRange | undefined) {
-    return {
-      getSelection: vi.fn((): SelectionRange | undefined => liveSelection),
-      setSelection: vi.fn(),
-    };
-  }
+/** Editor stub exposing only the selection and focus methods the selection-restoring helpers use. */
+function makeEditor(liveSelection: SelectionRange | undefined, selectedParaMarker?: string) {
+  return {
+    getSelection: vi.fn((): SelectionRange | undefined => liveSelection),
+    setSelection: vi.fn(),
+    getSelectedParaMarker: vi.fn((): string | undefined => selectedParaMarker),
+    focus: vi.fn(),
+  };
+}
 
+describe('restoreSelectionIfLost', () => {
   it('restores the snapshot when the live selection is gone', () => {
     const editor = makeEditor(undefined);
 
@@ -350,6 +354,17 @@ describe('restoreSelectionIfLost', () => {
     expect(editor.setSelection).not.toHaveBeenCalled();
   });
 
+  it('leaves a selected paragraph marker alone, so the dropdown retags that paragraph', () => {
+    // `getSelection()` reports undefined for a marker selection — a USJ selection is a text range
+    // and cannot represent a selected node — yet the selection is live. Restoring the snapshot over
+    // it would move the retag to whichever paragraph last held the caret.
+    const editor = makeEditor(undefined, 'li2');
+
+    restoreSelectionIfLost(editor, snapshot);
+
+    expect(editor.setSelection).not.toHaveBeenCalled();
+  });
+
   it('does nothing when the selection is gone but no snapshot was captured', () => {
     const editor = makeEditor(undefined);
 
@@ -365,6 +380,37 @@ describe('restoreSelectionIfLost', () => {
   });
 });
 
+describe('returnFocusToEditor', () => {
+  it('restores the snapshot before focusing, when the live selection is gone', () => {
+    // `focus()` falls back to selecting the document end when the editor-state selection is null, so
+    // the snapshot has to land first or the fallback wins.
+    const editor = makeEditor(undefined);
+
+    returnFocusToEditor(editor, snapshot);
+
+    expect(editor.setSelection).toHaveBeenCalledWith(snapshot);
+    expect(editor.focus).toHaveBeenCalledTimes(1);
+    const setSelectionOrder = editor.setSelection.mock.invocationCallOrder[0];
+    const focusOrder = editor.focus.mock.invocationCallOrder[0];
+    expect(setSelectionOrder).toBeLessThan(focusOrder);
+  });
+
+  it('focuses without restoring when a paragraph marker is selected', () => {
+    const editor = makeEditor(undefined, 'li2');
+
+    returnFocusToEditor(editor, snapshot);
+
+    expect(editor.setSelection).not.toHaveBeenCalled();
+    expect(editor.focus).toHaveBeenCalledTimes(1);
+  });
+
+  it('tolerates a null editor handle (ref not mounted)', () => {
+    // `editorRef.current` is genuinely `null` before the editor mounts — the exact value under test
+    // eslint-disable-next-line no-null/no-null
+    expect(() => returnFocusToEditor(null, snapshot)).not.toThrow();
+  });
+});
+
 describe('resolveEditingSessionActivity', () => {
   const NOW = 1_000_000;
 
diff --git a/extensions/src/platform-scripture-editor/src/platform-scripture-editor.web-view.utils.ts b/extensions/src/platform-scripture-editor/src/platform-scripture-editor.web-view.utils.ts
index e73903ee45a..5e0863aada7 100644
--- a/extensions/src/platform-scripture-editor/src/platform-scripture-editor.web-view.utils.ts
+++ b/extensions/src/platform-scripture-editor/src/platform-scripture-editor.web-view.utils.ts
@@ -177,19 +177,48 @@ export function resolveFootnotesPaneAutoVisibility({
  * A still-live selection is left completely alone, and with no snapshot there is nothing to restore
  * (`focus()` keeps its default behavior).
  *
+ * A selected paragraph marker counts as a live selection too. `getSelection()` reports `undefined`
+ * for it, because a USJ selection is a text range and cannot represent a selected node, so without
+ * asking `getSelectedParaMarker()` this would restore the last caret over it and the paragraph
+ * dropdown would retag whichever paragraph that caret was in.
+ *
  * @param editor The live editor handle (e.g. `editorRef.current`); no-op when not mounted
  * @param lastFocusOutSelection The selection captured when focus last left the editor (a focusout
  *   listener reads it synchronously, ahead of the blur-path nulling), or `undefined` when none has
  *   been captured
  */
 export function restoreSelectionIfLost(
-  editor: Pick<EditorRef, 'getSelection' | 'setSelection'> | null,
+  editor: Pick<EditorRef, 'getSelection' | 'setSelection' | 'getSelectedParaMarker'> | null,
   lastFocusOutSelection: SelectionRange | undefined,
 ): void {
-  if (!editor || editor.getSelection()) return;
+  if (!editor || editor.getSelection() || editor.getSelectedParaMarker()) return;
   if (lastFocusOutSelection) editor.setSelection(lastFocusOutSelection);
 }
 
+/**
+ * Puts keyboard focus back in the editor, restoring a lost caret first.
+ *
+ * Lexical's `focus()` falls back to selecting the document END when the editor-state selection is
+ * null, and it cannot tell a genuinely-lost selection from one that was never there — so the
+ * restore has to happen BEFORE `focus()` runs, never after. Calling `focus()` alone after a
+ * selection has been nulled (e.g. a popover blur) would silently move the caret to the chapter
+ * end.
+ *
+ * @param editor The live editor handle (e.g. `editorRef.current`); no-op when not mounted
+ * @param lastFocusOutSelection The selection captured when focus last left the editor, passed
+ *   straight through to {@link restoreSelectionIfLost}
+ */
+export function returnFocusToEditor(
+  editor: Pick<
+    EditorRef,
+    'getSelection' | 'setSelection' | 'getSelectedParaMarker' | 'focus'
+  > | null,
+  lastFocusOutSelection: SelectionRange | undefined,
+): void {
+  restoreSelectionIfLost(editor, lastFocusOutSelection);
+  editor?.focus();
+}
+
 /**
  * How long, in milliseconds, a footnote-popover editing session may sit without any interaction
  * (opening it, editing in it, or saving from it) before the PDP-sync deferral treats it as STALE —
diff --git a/extensions/src/platform-scripture-editor/src/use-paragraph-menu-open-state.hook.test.ts b/extensions/src/platform-scripture-editor/src/use-paragraph-menu-open-state.hook.test.ts
new file mode 100644
index 00000000000..cf81fd16ffa
--- /dev/null
+++ b/extensions/src/platform-scripture-editor/src/use-paragraph-menu-open-state.hook.test.ts
@@ -0,0 +1,100 @@
+// @vitest-environment jsdom
+
+import { act, renderHook } from '@testing-library/react';
+import { describe, expect, it, vi } from 'vitest';
+import {
+  useParagraphMenuOpenState,
+  type UseParagraphMenuOpenStateOptions,
+} from './use-paragraph-menu-open-state.hook';
+
+function renderOpenState(overrides: Partial<UseParagraphMenuOpenStateOptions> = {}) {
+  const notifyStructureProtected = vi.fn();
+  const initialProps: UseParagraphMenuOpenStateOptions = {
+    isReadOnly: false,
+    isStructureProtected: false,
+    hasBlockMarker: true,
+    notifyStructureProtected,
+    ...overrides,
+  };
+  const rendered = renderHook(
+    (props: UseParagraphMenuOpenStateOptions) => useParagraphMenuOpenState(props),
+    { initialProps },
+  );
+  return { ...rendered, initialProps, notifyStructureProtected };
+}
+
+describe('useParagraphMenuOpenState', () => {
+  it('starts closed', () => {
+    const { result } = renderOpenState();
+    expect(result.current.isMenuOpen).toBe(false);
+  });
+
+  it('opens from the editor when the menu is available', () => {
+    const { result } = renderOpenState();
+
+    act(() => result.current.requestMenuFromEditor());
+
+    expect(result.current.isMenuOpen).toBe(true);
+  });
+
+  it('notifies instead of opening while the structure is protected, so the key is never silently dropped', () => {
+    const { result, notifyStructureProtected } = renderOpenState({ isStructureProtected: true });
+
+    act(() => result.current.requestMenuFromEditor());
+
+    expect(result.current.isMenuOpen).toBe(false);
+    expect(notifyStructureProtected).toHaveBeenCalledTimes(1);
+  });
+
+  it('ignores an editor request in a read-only project, which has no paragraph menu at all', () => {
+    const { result, notifyStructureProtected } = renderOpenState({ isReadOnly: true });
+
+    act(() => result.current.requestMenuFromEditor());
+
+    expect(result.current.isMenuOpen).toBe(false);
+    expect(notifyStructureProtected).not.toHaveBeenCalled();
+  });
+
+  it('ignores an editor request while there is no block marker for the trigger to show', () => {
+    // The trigger renders nothing without a marker; an open state recorded now would spring the
+    // menu open the next time the caret enters a block.
+    const { result } = renderOpenState({ hasBlockMarker: false });
+
+    act(() => result.current.requestMenuFromEditor());
+
+    expect(result.current.isMenuOpen).toBe(false);
+  });
+
+  it('passes the toolbar button’s own open and close through', () => {
+    const { result } = renderOpenState();
+
+    act(() => result.current.setIsMenuOpen(true));
+    expect(result.current.isMenuOpen).toBe(true);
+
+    act(() => result.current.setIsMenuOpen(false));
+    expect(result.current.isMenuOpen).toBe(false);
+  });
+
+  it('closes when protection turns on and stays closed when it turns off', () => {
+    const { result, rerender, initialProps } = renderOpenState();
+    act(() => result.current.requestMenuFromEditor());
+    expect(result.current.isMenuOpen).toBe(true);
+
+    rerender({ ...initialProps, isStructureProtected: true });
+    expect(result.current.isMenuOpen).toBe(false);
+
+    rerender({ ...initialProps, isStructureProtected: false });
+    expect(result.current.isMenuOpen).toBe(false);
+  });
+
+  it('closes when the caret leaves every block and stays closed when it re-enters one', () => {
+    const { result, rerender, initialProps } = renderOpenState();
+    act(() => result.current.setIsMenuOpen(true));
+
+    rerender({ ...initialProps, hasBlockMarker: false });
+    expect(result.current.isMenuOpen).toBe(false);
+
+    rerender({ ...initialProps, hasBlockMarker: true });
+    expect(result.current.isMenuOpen).toBe(false);
+  });
+});
diff --git a/extensions/src/platform-scripture-editor/src/use-paragraph-menu-open-state.hook.ts b/extensions/src/platform-scripture-editor/src/use-paragraph-menu-open-state.hook.ts
new file mode 100644
index 00000000000..bd4e1f20ced
--- /dev/null
+++ b/extensions/src/platform-scripture-editor/src/use-paragraph-menu-open-state.hook.ts
@@ -0,0 +1,67 @@
+import { useCallback, useEffect, useState } from 'react';
+
+/** Inputs to {@link useParagraphMenuOpenState}. */
+export type UseParagraphMenuOpenStateOptions = {
+  /** Whether the editor is read-only; the toolbar has no paragraph menu then. */
+  isReadOnly: boolean;
+  /** Whether the project's structure is protected, which disables changing a paragraph's style. */
+  isStructureProtected: boolean;
+  /**
+   * Whether there is a block marker for the toolbar trigger to show; it renders nothing without
+   * one.
+   */
+  hasBlockMarker: boolean;
+  /** Tells the user the structure is locked, for a request the lock refuses. */
+  notifyStructureProtected: () => void;
+};
+
+/** Return type of {@link useParagraphMenuOpenState}. */
+export type ParagraphMenuOpenState = {
+  /** Whether the toolbar paragraph menu is open; pass to `ParagraphStyleTrigger`'s `isMenuOpen`. */
+  isMenuOpen: boolean;
+  /** Opens or closes the menu unconditionally; pass to `ParagraphStyleTrigger`'s `onMenuOpenChange`. */
+  setIsMenuOpen: (isOpen: boolean) => void;
+  /**
+   * Opens the menu for the editor's keyboard request, or reports the structure lock if it refuses
+   * one; pass to `<Editorial onParaMarkerMenuRequest>`.
+   */
+  requestMenuFromEditor: () => void;
+};
+
+/**
+ * Holds whether the toolbar paragraph menu is open, and turns the editor's keyboard request (Enter
+ * or Alt+Down on a selected paragraph marker, delivered as `onParaMarkerMenuRequest`) into opening
+ * it.
+ *
+ * A request the structure lock refuses is reported with the lock notification rather than dropped.
+ * A request in a read-only project, or with no block marker to show, is ignored: there is no menu
+ * to open. Whenever the menu stops being available it is closed, so it cannot spring open on its
+ * own when the lock lifts or the caret re-enters a block.
+ *
+ * @returns `isMenuOpen` for `ParagraphStyleTrigger`, `setIsMenuOpen` for its `onMenuOpenChange`,
+ *   and `requestMenuFromEditor` for `<Editorial onParaMarkerMenuRequest>`
+ */
+export function useParagraphMenuOpenState({
+  isReadOnly,
+  isStructureProtected,
+  hasBlockMarker,
+  notifyStructureProtected,
+}: UseParagraphMenuOpenStateOptions): ParagraphMenuOpenState {
+  const [isMenuOpen, setIsMenuOpen] = useState(false);
+  const isMenuAvailable = !isReadOnly && !isStructureProtected && hasBlockMarker;
+
+  useEffect(() => {
+    if (!isMenuAvailable) setIsMenuOpen(false);
+  }, [isMenuAvailable]);
+
+  const requestMenuFromEditor = useCallback(() => {
+    if (isReadOnly || !hasBlockMarker) return;
+    if (isStructureProtected) {
+      notifyStructureProtected();
+      return;
+    }
+    setIsMenuOpen(true);
+  }, [isReadOnly, hasBlockMarker, isStructureProtected, notifyStructureProtected]);
+
+  return { isMenuOpen, setIsMenuOpen, requestMenuFromEditor };
+}
diff --git a/extensions/src/platform-scripture-editor/src/usj-nodes-styles.test.ts b/extensions/src/platform-scripture-editor/src/usj-nodes-styles.test.ts
index 9038b64600c..2a0932d1f6d 100644
--- a/extensions/src/platform-scripture-editor/src/usj-nodes-styles.test.ts
+++ b/extensions/src/platform-scripture-editor/src/usj-nodes-styles.test.ts
@@ -20,6 +20,9 @@ import path from 'path';
  */
 describe('_usj-nodes.scss vendored editor stylesheet', () => {
   const scss = readFileSync(path.resolve(__dirname, '_usj-nodes.scss'), 'utf8');
+  /** The stylesheet with its comments removed, so prose that names a selector cannot match it. */
+  const declarations = scss.replace(/\/\*[\s\S]*?\*\//g, '');
+  const escape = (value: string) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 
   it('still styles the UnknownNode containers (guards against reading the wrong/empty file)', () => {
     expect(scss).toContain('.marker-editable .unknown-block');
@@ -43,12 +46,8 @@ describe('_usj-nodes.scss vendored editor stylesheet', () => {
    * whitespace and of the declaration's position within the block, so reformatting the stylesheet
    * cannot fail these pins for a reason that has nothing to do with what they guard.
    */
-  const rule = (selectors: string[], declaration: string) => {
-    const escape = (value: string) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    return new RegExp(
-      `${selectors.map(escape).join(',\\s*')}\\s*\\{[^}]*${escape(declaration)}[^}]*\\}`,
-    );
-  };
+  const rule = (selectors: string[], declaration: string) =>
+    new RegExp(`${selectors.map(escape).join(',\\s*')}\\s*\\{[^}]*${escape(declaration)}[^}]*\\}`);
 
   describe('PT9 Standard-view marker glyph styling', () => {
     // Standard view renders marker glyphs as MarkerNode spans carrying marker-syntax classes
@@ -237,6 +236,59 @@ describe('_usj-nodes.scss vendored editor stylesheet', () => {
     });
   });
 
+  describe('selected paragraph marker row', () => {
+    // The editor marks the paragraph whose gutter marker is selected with `psc-para-marker-selected`.
+    // Selection gets a channel of its own, as in adr-list-selection-on-a-dedicated-visual-channel,
+    // never the active-text focus box. Unlike that ADR's comment cards, the row also takes a fill
+    // (its background carries no status), and fill and bar reach across the gutter as box-shadows.
+    const block = (selector: string) =>
+      declarations.match(new RegExp(`${escape(selector)}\\s*\\{([^}]*)\\}`))?.[1];
+
+    // Which tokens the bar and glyph are painted in is pinned by
+    // paragraph-marker-selection-contrast.test.ts, next to the contrast sweep over those tokens.
+    it('fills the row and reaches the fill and bar toward the left in LTR', () => {
+      const ltr = block('.psc-gutter-markers .psc-para-marker-selected');
+      expect(ltr).toContain('background-color: var(--accent)');
+      // Toward inline-start, which is the left in LTR.
+      expect(ltr).toMatch(/box-shadow:\s*calc\(4px - var\(--psc-para-marker-selection-reach\)\)/);
+    });
+
+    it('mirrors the fill and bar to the right in RTL', () => {
+      const rtl = block(".psc-gutter-markers[dir='rtl'] .psc-para-marker-selected");
+      expect(rtl).toMatch(/box-shadow:\s*calc\(var\(--psc-para-marker-selection-reach\) - 4px\)/);
+    });
+
+    it('strengthens the selected glyph', () => {
+      const glyph = block(
+        '.psc-gutter-markers .psc-para-marker-selected > .marker:not(.verse):not(.chapter):first-child',
+      );
+      expect(glyph).toContain('font-weight: 700');
+    });
+
+    it('keeps the selected row visible in forced colors, which drop the box-shadow and fill', () => {
+      const forcedColors = declarations.match(
+        /@media \(forced-colors: active\)\s*\{\s*\.psc-gutter-markers \.psc-para-marker-selected\s*\{([^}]*)\}/,
+      )?.[1];
+      expect(forcedColors).toMatch(/outline:[^;]*\bHighlight\b/);
+    });
+
+    it('uses no pseudo-element, which the focus box and book code already own', () => {
+      expect(declarations).not.toMatch(/\.psc-para-marker-selected[^{,]*::?(?:before|after)/);
+    });
+
+    it('paints the selected glyph after the base gutter glyph rule, which has equal specificity', () => {
+      // Equal specificity (0,6,0): source order decides.
+      const baseGlyph = '.psc-gutter-markers .para > .marker:not(.verse):not(.chapter):first-child';
+      const selectedGlyph =
+        '.psc-gutter-markers .psc-para-marker-selected > .marker:not(.verse):not(.chapter):first-child';
+      const baseIndex = declarations.indexOf(baseGlyph);
+      const selectedIndex = declarations.indexOf(selectedGlyph);
+      expect(baseIndex).toBeGreaterThanOrEqual(0);
+      expect(selectedIndex).toBeGreaterThanOrEqual(0);
+      expect(selectedIndex).toBeGreaterThan(baseIndex);
+    });
+  });
+
   describe('cross-copy drift pins (must agree with the demo copy in platform-bible-react)', () => {
     // The two vendored copies of the editor stylesheet (this one and
     // lib/platform-bible-react/src/components/demo/scripture-editor/usj-nodes.css) are pinned at
@@ -254,14 +306,12 @@ describe('_usj-nodes.scss vendored editor stylesheet', () => {
     });
     it('renders the active-text outline via ::after, never ::before (book-code collision)', () => {
       expect(scss).toMatch(/\.psc-active-focus \.psc-active-text::after\s*\{/);
-      expect(scss.replace(/\/\*[\s\S]*?\*\//g, '')).not.toMatch(
-        /\.psc-active-focus \.psc-active-text::before/,
-      );
+      expect(declarations).not.toMatch(/\.psc-active-focus \.psc-active-text::before/);
     });
     it('does not override text-align in the RTL gutter rule (Chrome/Firefox bidi paint quirk)', () => {
-      const rtlGutter = scss
-        .replace(/\/\*[\s\S]*?\*\//g, '')
-        .match(/\.psc-gutter-markers\[dir='rtl'\] \.para[^{]*\{([^}]*)\}/);
+      const rtlGutter = declarations.match(
+        /\.psc-gutter-markers\[dir='rtl'\] \.para[^{]*\{([^}]*)\}/,
+      );
       expect(rtlGutter).not.toBeNull();
       expect(rtlGutter?.[1]).not.toContain('text-align');
     });
diff --git a/src/shared/data/keyboard-shortcuts.data.test.ts b/src/shared/data/keyboard-shortcuts.data.test.ts
index 8b6a8bdca98..54f4838c909 100644
--- a/src/shared/data/keyboard-shortcuts.data.test.ts
+++ b/src/shared/data/keyboard-shortcuts.data.test.ts
@@ -87,7 +87,21 @@ function getMenuLocationsByCommand(): Map<string, Set<string>> {
   return locationsByCommand;
 }
 
+/** Every (entry id, location) pair in the catalog, for a per-pair existence check. */
+const entryLocationPairs = rootKeyboardShortcuts.flatMap((entry) =>
+  entry.locations.map((location): [entryId: string, location: string] => [entry.id, location]),
+);
+
 describe('keyboard shortcuts catalog', () => {
+  it('has locations to check', () => {
+    // Guards the sweep below: an empty list would pass it by running nothing.
+    expect(entryLocationPairs.length).toBeGreaterThan(0);
+  });
+
+  it.each(entryLocationPairs)('%s location "%s" resolves to a real file', (_id, location) => {
+    expect(existsSync(path.join(process.cwd(), location))).toBe(true);
+  });
+
   it('commands match the expected menu hints', () => {
     // Sorted arrays rather than sets, so a `command` on two entries also fails
     const commands = entriesWithCommand.map((entry) => entry.command ?? '');
@@ -137,13 +151,6 @@ function zoomEntries() {
   return rootKeyboardShortcuts.filter((entry) => entry.category === 'Zoom');
 }
 
-/** All (entry id, location) pairs across the Zoom category, for a per-pair existence check. */
-function zoomEntryLocationPairs(): [entryId: string, location: string][] {
-  return zoomEntries().flatMap((entry) =>
-    entry.locations.map((location): [string, string] => [entry.id, location]),
-  );
-}
-
 describe('keyboard-shortcuts.data Zoom category', () => {
   it('has no leftover app-wide zoom entries for the removed main-process chords', () => {
     const ids = zoomEntries().map((entry) => entry.id);
@@ -159,8 +166,15 @@ describe('keyboard-shortcuts.data Zoom category', () => {
       expect(entry?.locations).toEqual(expect.arrayContaining(CONTENT_ZOOM_CHORD_LOCATIONS));
     },
   );
+});
+
+describe('paragraph marker menu chord', () => {
+  const entry = rootKeyboardShortcuts.find(
+    (shortcut) => shortcut.id === 'scripture-open-paragraph-menu-from-marker',
+  );
 
-  it.each(zoomEntryLocationPairs())('%s location "%s" resolves to a real file', (_id, location) => {
-    expect(existsSync(path.join(process.cwd(), location))).toBe(true);
+  it('shows no menu hint, since the chord works only on a selected paragraph marker', () => {
+    expect(entry).toBeDefined();
+    expect(entry?.command).toBeUndefined();
   });
 });
diff --git a/src/shared/data/keyboard-shortcuts.data.ts b/src/shared/data/keyboard-shortcuts.data.ts
index 3469740a328..9d2e6f6b706 100644
--- a/src/shared/data/keyboard-shortcuts.data.ts
+++ b/src/shared/data/keyboard-shortcuts.data.ts
@@ -532,6 +532,25 @@ export const rootKeyboardShortcuts: KeyboardShortcutEntry[] = [
       'extensions/src/platform-scripture-editor/src/platform-scripture-editor.web-view.tsx',
     ],
   },
+  {
+    id: 'scripture-open-paragraph-menu-from-marker',
+    purpose: 'Open the paragraph style menu to change the selected paragraph marker',
+    category: 'Editing',
+    // Handled inside the editor library that ships as the `@eten-tech-foundation/platform-editor`
+    // package: its `ParaMarkerSelectionPlugin` claims Enter and Alt+Down from a `KEY_DOWN_COMMAND`
+    // handler only while a paragraph marker is selected (by clicking its gutter glyph in the
+    // paragraph-structure view), and asks the web view to open its toolbar paragraph menu through
+    // `onParaMarkerMenuRequest`. `locations` names the in-repo code that answers that request.
+    // No `command`: the chord does nothing unless a paragraph marker is selected.
+    context:
+      'Scripture editor web view (handled by the @eten-tech-foundation/platform-editor package)',
+    keys: { macOS: '⏎ / ⌥↓', windows: 'Enter / Alt+↓', linux: 'Enter / Alt+↓' },
+    locations: [
+      'extensions/src/platform-scripture-editor/src/platform-scripture-editor.web-view.tsx',
+      'extensions/src/platform-scripture-editor/src/use-paragraph-menu-open-state.hook.ts',
+      'extensions/src/platform-scripture-editor/src/paragraph-style-trigger.component.tsx',
+    ],
+  },
   // The editor's arrow-key caret movement (verse hops, note boundaries, the two caret stops
   // around an \fp span's rendered line break — all in the scripture-editors repo's
   // ArrowNavigationPlugin) is deliberately NOT cataloged: arrow keys moving the caret in a