diff --git a/REVIEW.md b/REVIEW.md
index d8a19cfa..ef440b9f 100644
--- a/REVIEW.md
+++ b/REVIEW.md
@@ -18,6 +18,10 @@ Before reporting any documentation as missing, open the file and confirm the JSD
 
 Keyboard accessibility is planned but not yet implemented. Do not flag missing `tabIndex` attributes, absent `aria-*` roles, or gaps in focus management as issues — these will be addressed in a dedicated pass once the core interaction model is stable.
 
+## Buttons inside the TokenChip label
+
+The `<label>` in [src/components/TokenChip.tsx](src/components/TokenChip.tsx) contains a `<button>` (the morpheme trigger) when morphology is shown, which technically violates the HTML content model for `<label>` (no labelable descendants other than the labeled control). This is **intentional and already handled**: the explicit `htmlFor` binding to the gloss input takes precedence over implicit control resolution in all browsers, and the label's mouse-down handler explicitly routes focus around inputs and buttons. The comment above the label in that file documents the reasoning. Do not flag this as a spec violation or suggest restructuring the markup — moving the morpheme row outside the label would break click-to-focus on the chip body.
+
 ## Mock cleanup in tests
 
 [jest.config.ts](jest.config.ts) sets both `resetMocks: true` and `restoreMocks: true`. This means every `jest.spyOn(...)` is automatically restored to its original implementation after each test — tests do **not** need a manual `mockRestore()` or `jest.restoreAllMocks()` in `afterEach` for spies. Do not flag spies as leaking or suggest adding cleanup for them.
diff --git a/__mocks__/platform-bible-react.tsx b/__mocks__/platform-bible-react.tsx
index 496ac0b3..1007fc6f 100644
--- a/__mocks__/platform-bible-react.tsx
+++ b/__mocks__/platform-bible-react.tsx
@@ -3,8 +3,8 @@
  * without extra transform configuration. This stub provides the subset used by the extension.
  */
 
-import { forwardRef } from 'react';
-import type { ReactElement, ReactNode } from 'react';
+import { forwardRef, useEffect, useRef } from 'react';
+import type { MouseEventHandler, ReactElement, ReactNode } from 'react';
 
 export interface MenuItemContainingCommand {
   label: `%${string}%`;
@@ -323,6 +323,128 @@ export function Switch({
   );
 }
 
+/**
+ * Stub popover root that renders its children unconditionally. The extension conditionally mounts
+ * the content component while open (so its draft state re-initializes per open), so visibility
+ * needs no simulation here.
+ *
+ * @param props - Component props.
+ * @param props.children - Anchor and (while open) content elements.
+ * @returns The children unchanged.
+ */
+export function Popover({
+  children,
+}: Readonly<{ children?: ReactNode; open?: boolean; modal?: boolean }>): ReactElement {
+  return <>{children}</>;
+}
+
+/**
+ * Stub popover anchor that renders its children as-is, matching the real component's `asChild`
+ * pass-through behavior.
+ *
+ * @param props - Component props.
+ * @param props.children - The element the popover is anchored to.
+ * @returns The children unchanged.
+ */
+export function PopoverAnchor({
+  children,
+}: Readonly<{ children?: ReactNode; asChild?: boolean }>): ReactElement {
+  return <>{children}</>;
+}
+
+/**
+ * Stub popover content rendered as a plain `<div data-testid="popover-content">`. The real
+ * component implements positioning, portaling, and dismissal internally; this stub exposes the
+ * dismissal callbacks so tests can simulate them:
+ *
+ * - `onOpenAutoFocus` is invoked once on mount (mirroring Radix's open auto-focus event).
+ * - An Escape keydown anywhere inside the content invokes `onEscapeKeyDown`.
+ * - A sentinel `data-testid="popover-outside"` button invokes `onInteractOutside` on click,
+ *   simulating a pointer interaction outside the popover.
+ * - A sentinel `data-testid="popover-close"` button invokes `onCloseAutoFocus` on click,
+ *   simulating Radix's focus-restoration event fired as the popover closes.
+ *
+ * @param props - Component props.
+ * @param props.children - Panel content.
+ * @param props.className - CSS class names forwarded to the div.
+ * @param props.onEscapeKeyDown - Called with the native `KeyboardEvent` when Escape is pressed
+ *   inside the content, matching Radix's signature.
+ * @param props.onInteractOutside - Called with a `CustomEvent` carrying the original pointer event
+ *   in `detail.originalEvent` when the sentinel outside button is clicked, matching the shape of
+ *   Radix's `PointerDownOutsideEvent`.
+ * @param props.onOpenAutoFocus - Called once on mount with a plain `Event`.
+ * @param props.onCloseAutoFocus - Called with a plain `Event` when the sentinel close button is
+ *   clicked, mirroring Radix's close-time focus-restoration event.
+ * @param props.onClick - Click handler forwarded to the div.
+ * @param props.onMouseDown - Mouse-down handler forwarded to the div.
+ * @returns A `<div data-testid="popover-content">` with the panel content and sentinel controls.
+ */
+export function PopoverContent({
+  children,
+  className,
+  onEscapeKeyDown,
+  onInteractOutside,
+  onOpenAutoFocus,
+  onCloseAutoFocus,
+  onClick,
+  onMouseDown,
+}: Readonly<{
+  children?: ReactNode;
+  className?: string;
+  align?: 'start' | 'center' | 'end';
+  sideOffset?: number;
+  onEscapeKeyDown?: (event: KeyboardEvent) => void;
+  onInteractOutside?: (event: CustomEvent) => void;
+  onOpenAutoFocus?: (event: Event) => void;
+  onCloseAutoFocus?: (event: Event) => void;
+  onClick?: MouseEventHandler<HTMLDivElement>;
+  onMouseDown?: MouseEventHandler<HTMLDivElement>;
+}>): ReactElement {
+  // Capture the mount-time callback so the simulation fires exactly once, like the real event.
+  const openAutoFocusRef = useRef(onOpenAutoFocus);
+  useEffect(() => {
+    openAutoFocusRef.current?.(new Event('openAutoFocus'));
+  }, []);
+  return (
+    // eslint-disable-next-line jsx-a11y/no-static-element-interactions
+    <div
+      className={className}
+      data-testid="popover-content"
+      onClick={onClick}
+      onKeyDown={(e) => {
+        if (e.key === 'Escape') onEscapeKeyDown?.(e.nativeEvent);
+      }}
+      onMouseDown={onMouseDown}
+    >
+      {children}
+      {onInteractOutside && (
+        <button
+          data-testid="popover-outside"
+          type="button"
+          onClick={(e) =>
+            onInteractOutside(
+              new CustomEvent('dismissableLayer.pointerDownOutside', {
+                detail: { originalEvent: e.nativeEvent },
+              }),
+            )
+          }
+        >
+          outside
+        </button>
+      )}
+      {onCloseAutoFocus && (
+        <button
+          data-testid="popover-close"
+          type="button"
+          onClick={() => onCloseAutoFocus(new Event('closeAutoFocus'))}
+        >
+          close
+        </button>
+      )}
+    </div>
+  );
+}
+
 /**
  * Stub label rendered as a native `<label>` element.
  *
diff --git a/contributions/localizedStrings.json b/contributions/localizedStrings.json
index ed8f1dca..5d1cbaba 100644
--- a/contributions/localizedStrings.json
+++ b/contributions/localizedStrings.json
@@ -24,6 +24,16 @@
       "%interlinearizer_projectSettings_simplifyPhrasesDescription%": "Hide interactive controls (split, unlink, remove-token) on phrases that are not currently focused, leaving only their style change on hover",
       "%interlinearizer_projectSettings_chapterLabelInVerse%": "Show Chapter in Verse Label",
       "%interlinearizer_projectSettings_chapterLabelInVerseDescription%": "Mark chapter boundaries by labeling the first verse of each chapter as chapter:verse instead of showing an inline chapter header above it",
+      "%interlinearizer_viewOption_showMorphology%": "Show morphology",
+      "%interlinearizer_projectSettings_showMorphology%": "Show Morphology",
+      "%interlinearizer_projectSettings_showMorphologyDescription%": "Display morpheme breakdown and per-morpheme glosses beneath each word token",
+      "%interlinearizer_morphemeEditor_splitLabel%": "Split into morphemes",
+      "%interlinearizer_morphemeEditor_delete%": "Delete",
+      "%interlinearizer_morphemeEditor_cancel%": "Cancel",
+      "%interlinearizer_morphemeEditor_done%": "Done",
+      "%interlinearizer_morphemeGloss_label%": "Gloss for morpheme {form}",
+      "%interlinearizer_tokenChip_editMorphemes%": "Edit morpheme breakdown for {token}",
+      "%interlinearizer_tokenChip_defineMorphemes%": "Define morpheme breakdown for {token}",
       "%interlinearizer_linkButton_crossSegmentDisabledTooltip%": "Cross-segment phrases are not supported. This link button is outside the current segment.",
 
       "%interlinearizer_modal_create_title%": "Create Interlinear Project",
diff --git a/contributions/projectSettings.json b/contributions/projectSettings.json
index 769233ef..16f6a64d 100644
--- a/contributions/projectSettings.json
+++ b/contributions/projectSettings.json
@@ -21,6 +21,11 @@
         "label": "%interlinearizer_projectSettings_chapterLabelInVerse%",
         "description": "%interlinearizer_projectSettings_chapterLabelInVerseDescription%",
         "default": false
+      },
+      "interlinearizer.showMorphology": {
+        "label": "%interlinearizer_projectSettings_showMorphology%",
+        "description": "%interlinearizer_projectSettings_showMorphologyDescription%",
+        "default": false
       }
     }
   }
diff --git a/cspell.json b/cspell.json
index 04ae63db..d754598f 100644
--- a/cspell.json
+++ b/cspell.json
@@ -18,6 +18,7 @@
     "bara",
     "baselining",
     "BBCCCVVV",
+    "believ",
     "clickability",
     "cullable",
     "deconflict",
@@ -63,6 +64,7 @@
     "struc",
     "Stylesheet",
     "typedefs",
+    "unanalyzed",
     "unhover",
     "unobserves",
     "unphrased",
diff --git a/src/__tests__/components/AnalysisStore.test.tsx b/src/__tests__/components/AnalysisStore.test.tsx
index 9c823cb4..ad57a392 100644
--- a/src/__tests__/components/AnalysisStore.test.tsx
+++ b/src/__tests__/components/AnalysisStore.test.tsx
@@ -8,8 +8,13 @@ import type { TextAnalysis, TokenAnalysis, TokenAnalysisLink } from 'interlinear
 import {
   AnalysisStoreProvider,
   useAnalysis,
+  useAnalysisLanguage,
   useGloss,
   useGlossDispatch,
+  useMorphemeBreakdownDispatch,
+  useMorphemeDeleteDispatch,
+  useMorphemeGlossDispatch,
+  useMorphemes,
   usePhraseLinkByIdMap,
   usePhraseLinkForToken,
   usePhraseLinkMap,
@@ -812,3 +817,332 @@ describe('usePhraseGlossDispatch', () => {
     );
   });
 });
+
+// ---------------------------------------------------------------------------
+// Morpheme hooks
+// ---------------------------------------------------------------------------
+
+/**
+ * Renders the morpheme forms for a token, used to assert on `useMorphemes`.
+ *
+ * @param props.tokenRef - Token ref to subscribe to.
+ * @returns JSX element with joined morpheme forms.
+ */
+function MorphemeReader({ tokenRef }: Readonly<{ tokenRef: string }>) {
+  const morphemes = useMorphemes(tokenRef);
+  return <span data-testid="morphemes">{morphemes.map((m) => m.form).join(',')}</span>;
+}
+
+/**
+ * Renders the analysis language, used to assert on `useAnalysisLanguage`.
+ *
+ * @returns JSX element with the analysis language string.
+ */
+function LanguageReader() {
+  const lang = useAnalysisLanguage();
+  return <span data-testid="lang">{lang}</span>;
+}
+
+/**
+ * Renders a button that dispatches a morpheme breakdown, used to test
+ * `useMorphemeBreakdownDispatch`.
+ *
+ * @param props.tokenRef - Token ref to write.
+ * @param props.surfaceText - Surface text of the token.
+ * @param props.forms - Morpheme forms to write.
+ * @param props.writingSystem - Writing system of the token's surface text.
+ * @returns JSX element suitable for passing to `render`.
+ */
+function MorphemeWriter({
+  tokenRef,
+  surfaceText,
+  forms,
+  writingSystem,
+}: Readonly<{ tokenRef: string; surfaceText: string; forms: string[]; writingSystem: string }>) {
+  const dispatch = useMorphemeBreakdownDispatch();
+  return (
+    <button onClick={() => dispatch(tokenRef, surfaceText, forms, writingSystem)} type="button">
+      break
+    </button>
+  );
+}
+
+/**
+ * Renders a button that dispatches a morpheme breakdown deletion, used to test
+ * `useMorphemeDeleteDispatch`.
+ *
+ * @param props.tokenRef - Token ref whose breakdown to delete.
+ * @returns JSX element suitable for passing to `render`.
+ */
+function MorphemeDeleter({ tokenRef }: Readonly<{ tokenRef: string }>) {
+  const dispatch = useMorphemeDeleteDispatch();
+  return (
+    <button onClick={() => dispatch(tokenRef)} type="button">
+      delete-morphemes
+    </button>
+  );
+}
+
+/**
+ * Renders a button that dispatches a morpheme gloss, used to test `useMorphemeGlossDispatch`.
+ *
+ * @param props.tokenRef - Token ref to write.
+ * @param props.morphemeId - Morpheme id to gloss.
+ * @param props.value - Gloss value.
+ * @returns JSX element suitable for passing to `render`.
+ */
+function MorphemeGlossWriter({
+  tokenRef,
+  morphemeId,
+  value,
+}: Readonly<{ tokenRef: string; morphemeId: string; value: string }>) {
+  const dispatch = useMorphemeGlossDispatch();
+  return (
+    <button onClick={() => dispatch(tokenRef, morphemeId, value)} type="button">
+      gloss
+    </button>
+  );
+}
+
+/**
+ * Renders a component that calls `useMorphemes` without a provider, used to test the error.
+ *
+ * @returns Nothing — only mounted to trigger the throw.
+ */
+function MorphemesUser() {
+  useMorphemes('tok-1');
+  return undefined;
+}
+
+/**
+ * Renders a component that calls `useAnalysisLanguage` without a provider, used to test the error.
+ *
+ * @returns Nothing — only mounted to trigger the throw.
+ */
+function LanguageUser() {
+  useAnalysisLanguage();
+  return undefined;
+}
+
+/**
+ * Renders a component that calls `useMorphemeBreakdownDispatch` without a provider.
+ *
+ * @returns Nothing — only mounted to trigger the throw.
+ */
+function MorphemeBreakdownDispatchUser() {
+  useMorphemeBreakdownDispatch();
+  return undefined;
+}
+
+/**
+ * Renders a component that calls `useMorphemeGlossDispatch` without a provider.
+ *
+ * @returns Nothing — only mounted to trigger the throw.
+ */
+function MorphemeGlossDispatchUser() {
+  useMorphemeGlossDispatch();
+  return undefined;
+}
+
+/**
+ * Renders a component that calls `useMorphemeDeleteDispatch` without a provider.
+ *
+ * @returns Nothing — only mounted to trigger the throw.
+ */
+function MorphemeDeleteDispatchUser() {
+  useMorphemeDeleteDispatch();
+  return undefined;
+}
+
+describe('useMorphemes', () => {
+  it('returns empty array when no morphemes exist', () => {
+    render(
+      <AnalysisStoreProvider analysisLanguage="und">
+        <MorphemeReader tokenRef="tok-1" />
+      </AnalysisStoreProvider>,
+    );
+    expect(screen.getByTestId('morphemes')).toHaveTextContent('');
+  });
+
+  it('returns morphemes from an approved analysis with morphemes', () => {
+    const ta: TokenAnalysis = {
+      id: 'ta-1',
+      surfaceText: 'unbelievable',
+      morphemes: [
+        { id: 'm-1', form: 'un-', writingSystem: 'und' },
+        { id: 'm-2', form: 'believe', writingSystem: 'und' },
+      ],
+    };
+    const link: TokenAnalysisLink = {
+      analysisId: 'ta-1',
+      status: 'approved',
+      token: { tokenRef: 'tok-1', surfaceText: 'unbelievable' },
+    };
+    const analysis: TextAnalysis = {
+      segmentAnalyses: [],
+      segmentAnalysisLinks: [],
+      tokenAnalyses: [ta],
+      tokenAnalysisLinks: [link],
+      phraseAnalyses: [],
+      phraseAnalysisLinks: [],
+    };
+    render(
+      <AnalysisStoreProvider initialAnalysis={analysis} analysisLanguage="und">
+        <MorphemeReader tokenRef="tok-1" />
+      </AnalysisStoreProvider>,
+    );
+    expect(screen.getByTestId('morphemes')).toHaveTextContent('un-,believe');
+  });
+
+  it('throws when called outside an AnalysisStoreProvider', () => {
+    jest.spyOn(console, 'error').mockImplementation(() => {});
+    expect(() => render(<MorphemesUser />)).toThrow(
+      'useMorphemes must be used inside an AnalysisStoreProvider',
+    );
+  });
+});
+
+describe('useAnalysisLanguage', () => {
+  it('returns the analysis language from the provider', () => {
+    render(
+      <AnalysisStoreProvider analysisLanguage="fr">
+        <LanguageReader />
+      </AnalysisStoreProvider>,
+    );
+    expect(screen.getByTestId('lang')).toHaveTextContent('fr');
+  });
+
+  it('throws when called outside an AnalysisStoreProvider', () => {
+    jest.spyOn(console, 'error').mockImplementation(() => {});
+    expect(() => render(<LanguageUser />)).toThrow(
+      'useAnalysisLanguage must be used inside an AnalysisStoreProvider',
+    );
+  });
+});
+
+describe('useMorphemeBreakdownDispatch', () => {
+  it('writes morphemes and calls onSave', async () => {
+    const onSave = jest.fn();
+    render(
+      <AnalysisStoreProvider analysisLanguage="und" onSave={onSave}>
+        <MorphemeWriter
+          tokenRef="tok-1"
+          surfaceText="cat"
+          forms={['ca', '-t']}
+          writingSystem="en"
+        />
+        <MorphemeReader tokenRef="tok-1" />
+      </AnalysisStoreProvider>,
+    );
+
+    await userEvent.click(screen.getByRole('button', { name: 'break' }));
+
+    expect(screen.getByTestId('morphemes')).toHaveTextContent('ca,-t');
+    expect(onSave).toHaveBeenCalledTimes(1);
+    const saved: TextAnalysis = onSave.mock.calls[0][0];
+    expect(saved.tokenAnalyses).toHaveLength(1);
+    expect(saved.tokenAnalyses[0].morphemes).toHaveLength(2);
+    expect(saved.tokenAnalyses[0].morphemes?.[0].writingSystem).toBe('en');
+  });
+
+  it('throws when called outside an AnalysisStoreProvider', () => {
+    jest.spyOn(console, 'error').mockImplementation(() => {});
+    expect(() => render(<MorphemeBreakdownDispatchUser />)).toThrow(
+      'useMorphemeBreakdownDispatch must be used inside an AnalysisStoreProvider',
+    );
+  });
+});
+
+describe('useMorphemeDeleteDispatch', () => {
+  it('removes the morpheme breakdown and calls onSave', async () => {
+    const onSave = jest.fn();
+    const ta: TokenAnalysis = {
+      id: 'ta-1',
+      surfaceText: 'cat',
+      morphemes: [
+        { id: 'm-1', form: 'ca', writingSystem: 'und' },
+        { id: 'm-2', form: '-t', writingSystem: 'und' },
+      ],
+    };
+    const link: TokenAnalysisLink = {
+      analysisId: 'ta-1',
+      status: 'approved',
+      token: { tokenRef: 'tok-1', surfaceText: 'cat' },
+    };
+    const analysis: TextAnalysis = {
+      segmentAnalyses: [],
+      segmentAnalysisLinks: [],
+      tokenAnalyses: [ta],
+      tokenAnalysisLinks: [link],
+      phraseAnalyses: [],
+      phraseAnalysisLinks: [],
+    };
+    render(
+      <AnalysisStoreProvider initialAnalysis={analysis} analysisLanguage="und" onSave={onSave}>
+        <MorphemeDeleter tokenRef="tok-1" />
+        <MorphemeReader tokenRef="tok-1" />
+      </AnalysisStoreProvider>,
+    );
+
+    await userEvent.click(screen.getByRole('button', { name: 'delete-morphemes' }));
+
+    expect(screen.getByTestId('morphemes')).toHaveTextContent('');
+    expect(onSave).toHaveBeenCalledTimes(1);
+    const saved: TextAnalysis = onSave.mock.calls[0][0];
+    // The analysis carried no gloss, so the now-empty record and its link are removed entirely.
+    expect(saved.tokenAnalyses).toHaveLength(0);
+    expect(saved.tokenAnalysisLinks).toHaveLength(0);
+  });
+
+  it('throws when called outside an AnalysisStoreProvider', () => {
+    jest.spyOn(console, 'error').mockImplementation(() => {});
+    expect(() => render(<MorphemeDeleteDispatchUser />)).toThrow(
+      'useMorphemeDeleteDispatch must be used inside an AnalysisStoreProvider',
+    );
+  });
+});
+
+describe('useMorphemeGlossDispatch', () => {
+  it('writes a morpheme gloss and calls onSave', async () => {
+    const onSave = jest.fn();
+    const ta: TokenAnalysis = {
+      id: 'ta-1',
+      surfaceText: 'cat',
+      morphemes: [
+        { id: 'm-1', form: 'ca', writingSystem: 'und' },
+        { id: 'm-2', form: '-t', writingSystem: 'und' },
+      ],
+    };
+    const link: TokenAnalysisLink = {
+      analysisId: 'ta-1',
+      status: 'approved',
+      token: { tokenRef: 'tok-1', surfaceText: 'cat' },
+    };
+    const analysis: TextAnalysis = {
+      segmentAnalyses: [],
+      segmentAnalysisLinks: [],
+      tokenAnalyses: [ta],
+      tokenAnalysisLinks: [link],
+      phraseAnalyses: [],
+      phraseAnalysisLinks: [],
+    };
+    render(
+      <AnalysisStoreProvider initialAnalysis={analysis} analysisLanguage="und" onSave={onSave}>
+        <MorphemeGlossWriter tokenRef="tok-1" morphemeId="m-1" value="prefix" />
+      </AnalysisStoreProvider>,
+    );
+
+    await userEvent.click(screen.getByRole('button', { name: 'gloss' }));
+
+    expect(onSave).toHaveBeenCalledTimes(1);
+    const saved: TextAnalysis = onSave.mock.calls[0][0];
+    expect(saved.tokenAnalyses[0].morphemes?.[0].gloss).toStrictEqual({ und: 'prefix' });
+  });
+
+  it('throws when called outside an AnalysisStoreProvider', () => {
+    jest.spyOn(console, 'error').mockImplementation(() => {});
+    expect(() => render(<MorphemeGlossDispatchUser />)).toThrow(
+      'useMorphemeGlossDispatch must be used inside an AnalysisStoreProvider',
+    );
+  });
+});
diff --git a/src/__tests__/components/ContinuousView.test.tsx b/src/__tests__/components/ContinuousView.test.tsx
index d6458220..698d359f 100644
--- a/src/__tests__/components/ContinuousView.test.tsx
+++ b/src/__tests__/components/ContinuousView.test.tsx
@@ -10,6 +10,7 @@ import { useState, type ReactNode } from 'react';
 import type { PhraseDispatch } from '../../components/AnalysisStore';
 import ContinuousView from '../../components/ContinuousView';
 import { isWordToken } from '../../types/type-guards';
+import type { ViewOptions } from '../../types/view-options';
 import { withAnalysisStore } from './test-helpers';
 
 // ---------------------------------------------------------------------------
@@ -417,8 +418,7 @@ function requiredProps(
   tokenSegmentMap: ReadonlyMap<string, string>;
   tokenDocOrder: ReadonlyMap<string, number>;
   wordTokenByRef: ReadonlyMap<string, Token & { type: 'word' }>;
-  hideInactiveLinkButtons: boolean;
-  simplifyPhrases: boolean;
+  viewOptions: ViewOptions;
 } {
   const { tokenSegmentMap, tokenDocOrder, wordTokenByRef } = buildLookups(book);
   return {
@@ -431,8 +431,12 @@ function requiredProps(
     tokenSegmentMap,
     tokenDocOrder,
     wordTokenByRef,
-    hideInactiveLinkButtons: false,
-    simplifyPhrases: false,
+    viewOptions: {
+      hideInactiveLinkButtons: false,
+      simplifyPhrases: false,
+      chapterLabelInVerse: false,
+      showMorphology: false,
+    },
   };
 }
 
@@ -897,8 +901,12 @@ describe('ContinuousView scroll behavior', () => {
           tokenSegmentMap={tokenSegmentMap}
           tokenDocOrder={tokenDocOrder}
           wordTokenByRef={wordTokenByRef}
-          hideInactiveLinkButtons={false}
-          simplifyPhrases={false}
+          viewOptions={{
+            hideInactiveLinkButtons: false,
+            simplifyPhrases: false,
+            chapterLabelInVerse: false,
+            showMorphology: false,
+          }}
         />
       );
     }
@@ -943,8 +951,12 @@ describe('ContinuousView scroll behavior', () => {
           tokenSegmentMap={tokenSegmentMap}
           tokenDocOrder={tokenDocOrder}
           wordTokenByRef={wordTokenByRef}
-          hideInactiveLinkButtons
-          simplifyPhrases={false}
+          viewOptions={{
+            hideInactiveLinkButtons: true,
+            simplifyPhrases: false,
+            chapterLabelInVerse: false,
+            showMorphology: false,
+          }}
         />
       );
     }
@@ -1111,11 +1123,38 @@ describe('ContinuousView scroll behavior', () => {
     scrollIntoViewMock.mockClear();
 
     // Toggling hideInactiveLinkButtons should not cause any re-centering.
-    rerender(<ContinuousView {...props} hideInactiveLinkButtons />);
+    rerender(
+      <ContinuousView
+        {...props}
+        viewOptions={{ ...props.viewOptions, hideInactiveLinkButtons: true }}
+      />,
+    );
     expect(scrollIntoViewMock).not.toHaveBeenCalled();
 
     // Toggling simplifyPhrases re-centers exactly once (no rAF loop needed).
-    rerender(<ContinuousView {...props} hideInactiveLinkButtons simplifyPhrases />);
+    rerender(
+      <ContinuousView
+        {...props}
+        viewOptions={{ ...props.viewOptions, hideInactiveLinkButtons: true, simplifyPhrases: true }}
+      />,
+    );
+    expect(scrollIntoViewMock).toHaveBeenCalledWith(
+      expect.objectContaining({ behavior: 'auto', inline: 'center' }),
+    );
+    expect(scrollIntoViewMock).toHaveBeenCalledTimes(1);
+  });
+
+  it('re-centers once when showMorphology toggles', () => {
+    // Morpheme rows beneath tokens can widen phrase boxes, shifting the strip layout, so the
+    // focused group must be snapped back to center when the toggle flips.
+    const book = makeBook();
+    const props = requiredProps(book, { focusedTokenRef: 'tok-0' });
+    const { rerender } = render(<ContinuousView {...props} />, withAnalysisStore);
+    scrollIntoViewMock.mockClear();
+
+    rerender(
+      <ContinuousView {...props} viewOptions={{ ...props.viewOptions, showMorphology: true }} />,
+    );
     expect(scrollIntoViewMock).toHaveBeenCalledWith(
       expect.objectContaining({ behavior: 'auto', inline: 'center' }),
     );
diff --git a/src/__tests__/components/Interlinearizer.test.tsx b/src/__tests__/components/Interlinearizer.test.tsx
index 3e8f5d44..4c2d7bd5 100644
--- a/src/__tests__/components/Interlinearizer.test.tsx
+++ b/src/__tests__/components/Interlinearizer.test.tsx
@@ -353,6 +353,7 @@ function renderInterlinearizer({
   hideInactiveLinkButtons = false,
   simplifyPhrases = false,
   chapterLabelInVerse = false,
+  showMorphology = false,
 }: {
   book?: Book;
   continuousScroll?: boolean;
@@ -361,6 +362,7 @@ function renderInterlinearizer({
   hideInactiveLinkButtons?: boolean;
   simplifyPhrases?: boolean;
   chapterLabelInVerse?: boolean;
+  showMorphology?: boolean;
 } = {}) {
   return render(
     withNav(
@@ -371,9 +373,12 @@ function renderInterlinearizer({
         analysisLanguage="und"
         phraseMode={{ kind: 'view' }}
         setPhraseMode={() => {}}
-        hideInactiveLinkButtons={hideInactiveLinkButtons}
-        simplifyPhrases={simplifyPhrases}
-        chapterLabelInVerse={chapterLabelInVerse}
+        viewOptions={{
+          hideInactiveLinkButtons,
+          simplifyPhrases,
+          chapterLabelInVerse,
+          showMorphology,
+        }}
       />,
       navigate,
     ),
@@ -511,9 +516,12 @@ describe('Interlinearizer', () => {
             analysisLanguage="und"
             phraseMode={{ kind: 'view' }}
             setPhraseMode={() => {}}
-            hideInactiveLinkButtons={false}
-            simplifyPhrases={false}
-            chapterLabelInVerse={false}
+            viewOptions={{
+              hideInactiveLinkButtons: false,
+              simplifyPhrases: false,
+              chapterLabelInVerse: false,
+              showMorphology: false,
+            }}
           />,
         ),
       );
@@ -623,9 +631,12 @@ describe('Interlinearizer', () => {
             analysisLanguage="und"
             phraseMode={{ kind: 'view' }}
             setPhraseMode={() => {}}
-            hideInactiveLinkButtons={false}
-            simplifyPhrases={false}
-            chapterLabelInVerse={false}
+            viewOptions={{
+              hideInactiveLinkButtons: false,
+              simplifyPhrases: false,
+              chapterLabelInVerse: false,
+              showMorphology: false,
+            }}
           />,
         ),
       );
@@ -659,9 +670,12 @@ describe('Interlinearizer', () => {
             analysisLanguage="und"
             phraseMode={{ kind: 'view' }}
             setPhraseMode={() => {}}
-            hideInactiveLinkButtons={false}
-            simplifyPhrases={false}
-            chapterLabelInVerse={false}
+            viewOptions={{
+              hideInactiveLinkButtons: false,
+              simplifyPhrases: false,
+              chapterLabelInVerse: false,
+              showMorphology: false,
+            }}
           />,
         ),
       );
@@ -700,9 +714,12 @@ describe('Interlinearizer', () => {
           analysisLanguage="und"
           phraseMode={{ kind: 'view' }}
           setPhraseMode={() => {}}
-          hideInactiveLinkButtons={false}
-          simplifyPhrases={false}
-          chapterLabelInVerse={false}
+          viewOptions={{
+            hideInactiveLinkButtons: false,
+            simplifyPhrases: false,
+            chapterLabelInVerse: false,
+            showMorphology: false,
+          }}
         />,
       ),
     );
@@ -718,9 +735,12 @@ describe('Interlinearizer', () => {
           analysisLanguage="und"
           phraseMode={{ kind: 'view' }}
           setPhraseMode={() => {}}
-          hideInactiveLinkButtons={false}
-          simplifyPhrases={false}
-          chapterLabelInVerse={false}
+          viewOptions={{
+            hideInactiveLinkButtons: false,
+            simplifyPhrases: false,
+            chapterLabelInVerse: false,
+            showMorphology: false,
+          }}
         />,
       ),
     );
@@ -761,9 +781,12 @@ describe('Interlinearizer', () => {
           analysisLanguage="und"
           phraseMode={{ kind: 'view' }}
           setPhraseMode={() => {}}
-          hideInactiveLinkButtons={false}
-          simplifyPhrases={false}
-          chapterLabelInVerse={false}
+          viewOptions={{
+            hideInactiveLinkButtons: false,
+            simplifyPhrases: false,
+            chapterLabelInVerse: false,
+            showMorphology: false,
+          }}
         />,
       ),
     );
@@ -798,9 +821,12 @@ describe('Interlinearizer', () => {
             analysisLanguage="und"
             phraseMode={{ kind: 'view' }}
             setPhraseMode={() => {}}
-            hideInactiveLinkButtons={false}
-            simplifyPhrases={false}
-            chapterLabelInVerse={false}
+            viewOptions={{
+              hideInactiveLinkButtons: false,
+              simplifyPhrases: false,
+              chapterLabelInVerse: false,
+              showMorphology: false,
+            }}
           />,
         ),
       );
@@ -894,9 +920,12 @@ describe('Interlinearizer', () => {
           analysisLanguage="und"
           phraseMode={{ kind: 'view' }}
           setPhraseMode={() => {}}
-          hideInactiveLinkButtons={false}
-          simplifyPhrases={false}
-          chapterLabelInVerse={false}
+          viewOptions={{
+            hideInactiveLinkButtons: false,
+            simplifyPhrases: false,
+            chapterLabelInVerse: false,
+            showMorphology: false,
+          }}
         />,
       ),
     );
@@ -919,9 +948,12 @@ describe('Interlinearizer', () => {
             originalTokens: [{ tokenRef: 'GEN 1:1:0', surfaceText: 'In' }],
           }}
           setPhraseMode={() => {}}
-          hideInactiveLinkButtons={false}
-          simplifyPhrases={false}
-          chapterLabelInVerse={false}
+          viewOptions={{
+            hideInactiveLinkButtons: false,
+            simplifyPhrases: false,
+            chapterLabelInVerse: false,
+            showMorphology: false,
+          }}
         />,
       ),
     );
@@ -938,9 +970,12 @@ describe('Interlinearizer', () => {
           analysisLanguage="und"
           phraseMode={{ kind: 'confirm-unlink', phraseId: 'phrase-1' }}
           setPhraseMode={() => {}}
-          hideInactiveLinkButtons={false}
-          simplifyPhrases={false}
-          chapterLabelInVerse={false}
+          viewOptions={{
+            hideInactiveLinkButtons: false,
+            simplifyPhrases: false,
+            chapterLabelInVerse: false,
+            showMorphology: false,
+          }}
         />,
       ),
     );
@@ -959,9 +994,12 @@ describe('Interlinearizer', () => {
           analysisLanguage="und"
           phraseMode={{ kind: 'edit', phraseId: 'phrase-1', originalTokens, revert: true }}
           setPhraseMode={setPhraseMode}
-          hideInactiveLinkButtons={false}
-          simplifyPhrases={false}
-          chapterLabelInVerse={false}
+          viewOptions={{
+            hideInactiveLinkButtons: false,
+            simplifyPhrases: false,
+            chapterLabelInVerse: false,
+            showMorphology: false,
+          }}
         />,
       ),
     );
@@ -980,9 +1018,12 @@ describe('Interlinearizer', () => {
           analysisLanguage="und"
           phraseMode={{ kind: 'edit', phraseId: 'phrase-1', originalTokens: [], revert: true }}
           setPhraseMode={setPhraseMode}
-          hideInactiveLinkButtons={false}
-          simplifyPhrases={false}
-          chapterLabelInVerse={false}
+          viewOptions={{
+            hideInactiveLinkButtons: false,
+            simplifyPhrases: false,
+            chapterLabelInVerse: false,
+            showMorphology: false,
+          }}
         />,
       ),
     );
@@ -1000,9 +1041,12 @@ describe('Interlinearizer', () => {
         analysisLanguage: 'und',
         phraseMode: { kind: 'view' } as const,
         setPhraseMode: () => {},
-        hideInactiveLinkButtons: false,
-        simplifyPhrases: false,
-        chapterLabelInVerse: false,
+        viewOptions: {
+          hideInactiveLinkButtons: false,
+          simplifyPhrases: false,
+          chapterLabelInVerse: false,
+          showMorphology: false,
+        },
       };
       const { container, rerender } = render(
         withNav(
@@ -1068,9 +1112,12 @@ describe('Interlinearizer', () => {
           analysisLanguage="und"
           phraseMode={{ kind: 'view' }}
           setPhraseMode={() => {}}
-          hideInactiveLinkButtons={false}
-          simplifyPhrases={false}
-          chapterLabelInVerse={false}
+          viewOptions={{
+            hideInactiveLinkButtons: false,
+            simplifyPhrases: false,
+            chapterLabelInVerse: false,
+            showMorphology: false,
+          }}
         />
       );
     }
@@ -1099,9 +1146,12 @@ describe('Interlinearizer', () => {
         scrRef: { book: 'GEN', chapterNum: 1, verseNum: 1 },
         phraseMode: { kind: 'view' } as const,
         setPhraseMode: () => {},
-        hideInactiveLinkButtons: false,
-        simplifyPhrases: false,
-        chapterLabelInVerse: false,
+        viewOptions: {
+          hideInactiveLinkButtons: false,
+          simplifyPhrases: false,
+          chapterLabelInVerse: false,
+          showMorphology: false,
+        },
       };
       const { container, rerender } = render(
         withNav(<Interlinearizer {...props} continuousScroll={false} />),
diff --git a/src/__tests__/components/InterlinearizerLoader.test.tsx b/src/__tests__/components/InterlinearizerLoader.test.tsx
index 5a352e6e..841b4601 100644
--- a/src/__tests__/components/InterlinearizerLoader.test.tsx
+++ b/src/__tests__/components/InterlinearizerLoader.test.tsx
@@ -15,6 +15,7 @@ import useInterlinearizerBookData from '../../hooks/useInterlinearizerBookData';
 import useOptimisticBooleanSetting from '../../hooks/useOptimisticBooleanSetting';
 import { emptyAnalysis } from '../../types/empty-factories';
 import type { PhraseMode } from '../../types/phrase-mode';
+import type { ViewOptions } from '../../types/view-options';
 import { defaultScrRef, GEN_1_1_BOOK, makeWebViewState } from '../test-helpers';
 
 jest.mock('../../hooks/useInterlinearizerBookData');
@@ -31,6 +32,8 @@ jest.mock('../../components/controls/ViewOptionsDropdown', () => ({
     onSimplifyPhrasesChange,
     chapterLabelInVerse,
     onChapterLabelInVerseChange,
+    showMorphology,
+    onShowMorphologyChange,
   }: {
     continuousScroll: boolean;
     onContinuousScrollChange: (v: boolean) => void;
@@ -40,6 +43,8 @@ jest.mock('../../components/controls/ViewOptionsDropdown', () => ({
     onSimplifyPhrasesChange: (v: boolean) => void;
     chapterLabelInVerse: boolean;
     onChapterLabelInVerseChange: (v: boolean) => void;
+    showMorphology: boolean;
+    onShowMorphologyChange: (v: boolean) => void;
   }) => (
     <div data-testid="view-options-dropdown">
       <button
@@ -70,6 +75,13 @@ jest.mock('../../components/controls/ViewOptionsDropdown', () => ({
         onClick={() => onChapterLabelInVerseChange(!chapterLabelInVerse)}
         type="button"
       />
+      <button
+        aria-label="show morphology"
+        data-testid="show-morphology-toggle"
+        data-checked={String(showMorphology)}
+        onClick={() => onShowMorphologyChange(!showMorphology)}
+        type="button"
+      />
     </div>
   ),
 }));
@@ -94,9 +106,7 @@ type CapturedInterlinearizerProps = {
   onSaveAnalysis?: (analysis: TextAnalysis) => void;
   phraseMode: PhraseMode;
   setPhraseMode: Dispatch<SetStateAction<PhraseMode>>;
-  hideInactiveLinkButtons: boolean;
-  simplifyPhrases: boolean;
-  chapterLabelInVerse: boolean;
+  viewOptions: ViewOptions;
 };
 let capturedInterlinearizerProps: CapturedInterlinearizerProps | undefined;
 let interlinearizerMountCount = 0;
@@ -540,7 +550,7 @@ describe('InterlinearizerLoader', () => {
       />,
     );
 
-    expect(capturedInterlinearizerProps?.hideInactiveLinkButtons).toBe(false);
+    expect(capturedInterlinearizerProps?.viewOptions.hideInactiveLinkButtons).toBe(false);
   });
 
   it('wires ViewOptionsDropdown hide-inactive-link-buttons to onChange from useOptimisticBooleanSetting', async () => {
@@ -566,7 +576,7 @@ describe('InterlinearizerLoader', () => {
       />,
     );
 
-    expect(capturedInterlinearizerProps?.simplifyPhrases).toBe(false);
+    expect(capturedInterlinearizerProps?.viewOptions.simplifyPhrases).toBe(false);
   });
 
   it('wires ViewOptionsDropdown dim-inactive-segments to onChange from useOptimisticBooleanSetting', async () => {
@@ -592,7 +602,7 @@ describe('InterlinearizerLoader', () => {
       />,
     );
 
-    expect(capturedInterlinearizerProps?.chapterLabelInVerse).toBe(false);
+    expect(capturedInterlinearizerProps?.viewOptions.chapterLabelInVerse).toBe(false);
   });
 
   it('wires ViewOptionsDropdown chapter-label-in-verse to onChange from useOptimisticBooleanSetting', async () => {
@@ -609,6 +619,32 @@ describe('InterlinearizerLoader', () => {
     expect(onChangeByKey.get('interlinearizer.chapterLabelInVerse')).toHaveBeenCalledWith(true);
   });
 
+  it('passes showMorphology=false to Interlinearizer by default', () => {
+    render(
+      <InterlinearizerLoader
+        projectId={testProjectId}
+        useWebViewScrollGroupScrRef={makeScrollGroupHook()}
+        useWebViewState={makeWebViewState()}
+      />,
+    );
+
+    expect(capturedInterlinearizerProps?.viewOptions.showMorphology).toBe(false);
+  });
+
+  it('wires ViewOptionsDropdown show-morphology to onChange from useOptimisticBooleanSetting', async () => {
+    const onChangeByKey = mockOptimisticSetting();
+    render(
+      <InterlinearizerLoader
+        projectId={testProjectId}
+        useWebViewScrollGroupScrRef={makeScrollGroupHook()}
+        useWebViewState={makeWebViewState()}
+      />,
+    );
+
+    await userEvent.click(screen.getByTestId('show-morphology-toggle'));
+    expect(onChangeByKey.get('interlinearizer.showMorphology')).toHaveBeenCalledWith(true);
+  });
+
   it('passes continuousScroll=true to Interlinearizer when the setting is true', () => {
     mockOptimisticSetting(true);
     render(
diff --git a/src/__tests__/components/MorphemeEditor.test.tsx b/src/__tests__/components/MorphemeEditor.test.tsx
new file mode 100644
index 00000000..4c3eff3e
--- /dev/null
+++ b/src/__tests__/components/MorphemeEditor.test.tsx
@@ -0,0 +1,370 @@
+/** @file Unit tests for components/MorphemeEditor.tsx. */
+/// <reference types="jest" />
+/// <reference types="@testing-library/jest-dom" />
+
+import { useLocalizedStrings } from '@papi/frontend/react';
+import { fireEvent, render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import type { ComponentProps } from 'react';
+import * as AnalysisStore from '../../components/AnalysisStore';
+import { MorphemeBreakdownPopover, MorphemeGlossInput } from '../../components/MorphemeEditor';
+
+jest.mock('../../components/AnalysisStore');
+
+const LOCALIZED = {
+  '%interlinearizer_morphemeEditor_splitLabel%': 'Split into morphemes',
+  '%interlinearizer_morphemeEditor_delete%': 'Delete',
+  '%interlinearizer_morphemeEditor_cancel%': 'Cancel',
+  '%interlinearizer_morphemeEditor_done%': 'Done',
+  '%interlinearizer_morphemeGloss_label%': 'Gloss for morpheme {form}',
+};
+
+beforeEach(() => {
+  jest.mocked(useLocalizedStrings).mockReturnValue([LOCALIZED, false]);
+});
+
+/**
+ * Renders {@link MorphemeBreakdownPopover} with the two structural props (`surfaceText`,
+ * `glossInputId`) defaulted so each test only supplies what it asserts on.
+ *
+ * @param props - Overrides merged over the defaults; callers pass their own `onSave`/`onClose`
+ *   spies.
+ * @returns The render result.
+ */
+function renderPopover(props: Partial<ComponentProps<typeof MorphemeBreakdownPopover>> = {}) {
+  return render(
+    <MorphemeBreakdownPopover
+      glossInputId="gloss-1"
+      initialValue="test"
+      onClose={jest.fn()}
+      onSave={jest.fn()}
+      surfaceText="word"
+      {...props}
+    />,
+  );
+}
+
+describe('MorphemeBreakdownPopover', () => {
+  it('renders with the initial value pre-filled', () => {
+    renderPopover({ initialValue: 'un- believe -able' });
+    const input = screen.getByRole('textbox');
+    expect(input).toHaveValue('un- believe -able');
+  });
+
+  it('auto-focuses and selects the input on mount', () => {
+    renderPopover({ initialValue: 'word' });
+    expect(screen.getByRole('textbox')).toHaveFocus();
+  });
+
+  it('calls onSave and onClose when Done button is clicked', async () => {
+    const onSave = jest.fn();
+    const onClose = jest.fn();
+    renderPopover({ initialValue: 'un- believe', onSave, onClose, surfaceText: 'unbelieve' });
+    await userEvent.click(screen.getByRole('button', { name: 'Done' }));
+    expect(onSave).toHaveBeenCalledWith('un- believe');
+    expect(onClose).toHaveBeenCalledTimes(1);
+  });
+
+  it('calls onSave with the edited value', async () => {
+    const onSave = jest.fn();
+    renderPopover({ initialValue: 'word', onSave, surfaceText: 'word' });
+    await userEvent.clear(screen.getByRole('textbox'));
+    await userEvent.type(screen.getByRole('textbox'), 'wor -d');
+    await userEvent.click(screen.getByRole('button', { name: 'Done' }));
+    expect(onSave).toHaveBeenCalledWith('wor -d');
+  });
+
+  it('does not save when Done is clicked with unchanged text and an existing breakdown', async () => {
+    const onSave = jest.fn();
+    const onClose = jest.fn();
+    renderPopover({
+      initialValue: 'un- believe',
+      onSave,
+      onClose,
+      onDelete: jest.fn(),
+      surfaceText: 'unbelieve',
+    });
+    await userEvent.click(screen.getByRole('button', { name: 'Done' }));
+    expect(onSave).not.toHaveBeenCalled();
+    expect(onClose).toHaveBeenCalledTimes(1);
+  });
+
+  it('saves when Done is clicked with edited text and an existing breakdown', async () => {
+    const onSave = jest.fn();
+    renderPopover({
+      initialValue: 'un- believe',
+      onSave,
+      onDelete: jest.fn(),
+      surfaceText: 'unbelieve',
+    });
+    await userEvent.type(screen.getByRole('textbox'), ' -r');
+    await userEvent.click(screen.getByRole('button', { name: 'Done' }));
+    expect(onSave).toHaveBeenCalledWith('un- believe -r');
+  });
+
+  it('commits a multi-morpheme breakdown on Enter key', async () => {
+    const onSave = jest.fn();
+    const onClose = jest.fn();
+    renderPopover({ initialValue: 'te -st', onSave, onClose, surfaceText: 'test' });
+    await userEvent.keyboard('{Enter}');
+    expect(onSave).toHaveBeenCalledWith('te -st');
+    expect(onClose).toHaveBeenCalledTimes(1);
+  });
+
+  it('dismisses without saving on Escape key', async () => {
+    const onSave = jest.fn();
+    const onClose = jest.fn();
+    renderPopover({ initialValue: 'te -st', onSave, onClose, surfaceText: 'test' });
+    await userEvent.keyboard('{Escape}');
+    expect(onSave).not.toHaveBeenCalled();
+    expect(onClose).toHaveBeenCalledTimes(1);
+  });
+
+  it('dismisses without saving when Cancel button is clicked', async () => {
+    const onSave = jest.fn();
+    const onClose = jest.fn();
+    renderPopover({ initialValue: 'te -st', onSave, onClose, surfaceText: 'test' });
+    await userEvent.click(screen.getByRole('button', { name: 'Cancel' }));
+    expect(onSave).not.toHaveBeenCalled();
+    expect(onClose).toHaveBeenCalledTimes(1);
+  });
+
+  it('closes without saving when interacting outside with unchanged text', async () => {
+    const onSave = jest.fn();
+    const onClose = jest.fn();
+    renderPopover({ initialValue: 'te -st', onSave, onClose, surfaceText: 'test' });
+    // The platform-bible-react mock exposes a sentinel button that fires onInteractOutside,
+    // simulating a pointer interaction outside the popover.
+    await userEvent.click(screen.getByTestId('popover-outside'));
+    expect(onSave).not.toHaveBeenCalled();
+    expect(onClose).toHaveBeenCalledTimes(1);
+  });
+
+  it('saves on outside interaction when the text was edited', async () => {
+    const onSave = jest.fn();
+    renderPopover({ initialValue: 'test', onSave, surfaceText: 'whole' });
+    await userEvent.type(screen.getByRole('textbox'), ' -er');
+    await userEvent.click(screen.getByTestId('popover-outside'));
+    expect(onSave).toHaveBeenCalledWith('test -er');
+  });
+
+  it('does not save on outside interaction when the input is only whitespace', async () => {
+    const onSave = jest.fn();
+    renderPopover({ initialValue: '   ', onSave });
+    await userEvent.click(screen.getByTestId('popover-outside'));
+    expect(onSave).not.toHaveBeenCalled();
+  });
+
+  it('does not dismiss when clicking inside the popover panel', async () => {
+    const onClose = jest.fn();
+    renderPopover({ onClose });
+    const label = screen.getByText('Split into morphemes');
+    await userEvent.click(label);
+    expect(onClose).not.toHaveBeenCalled();
+  });
+
+  it('stops clicks inside the panel from reaching ancestor click handlers', async () => {
+    // The panel is portaled to document.body, but React synthetic events bubble through the React
+    // tree to the token chip and its phrase-selection click handlers; the panel must contain them.
+    const ancestorClick = jest.fn();
+    render(
+      <div role="presentation" onClick={ancestorClick}>
+        <MorphemeBreakdownPopover
+          glossInputId="gloss-1"
+          initialValue="test"
+          onClose={jest.fn()}
+          onSave={jest.fn()}
+          surfaceText="word"
+        />
+      </div>,
+    );
+    await userEvent.click(screen.getByText('Split into morphemes'));
+    expect(ancestorClick).not.toHaveBeenCalled();
+  });
+
+  it('stops mouse-downs inside the panel from reaching ancestor mouse-down handlers', () => {
+    // A mouse-down that escaped the panel would reach the chip label's mouse-down handler, which
+    // focuses the gloss input behind the popover and blurs the editor mid-edit.
+    const ancestorMouseDown = jest.fn();
+    render(
+      <div role="presentation" onMouseDown={ancestorMouseDown}>
+        <MorphemeBreakdownPopover
+          glossInputId="gloss-1"
+          initialValue="test"
+          onClose={jest.fn()}
+          onSave={jest.fn()}
+          surfaceText="word"
+        />
+      </div>,
+    );
+    fireEvent.mouseDown(screen.getByText('Split into morphemes'));
+    expect(ancestorMouseDown).not.toHaveBeenCalled();
+  });
+
+  it('disables Done when the input is only whitespace', () => {
+    renderPopover({ initialValue: '   ' });
+    expect(screen.getByRole('button', { name: 'Done' })).toBeDisabled();
+  });
+
+  it('does not save whitespace on Enter', async () => {
+    const onSave = jest.fn();
+    renderPopover({ initialValue: '  ', onSave, surfaceText: 'word' });
+    await userEvent.keyboard('{Enter}');
+    expect(onSave).not.toHaveBeenCalled();
+  });
+
+  it('disables Done for a breakdown that is just the whole word as one morpheme', () => {
+    renderPopover({ initialValue: 'word', surfaceText: 'word' });
+    expect(screen.getByRole('button', { name: 'Done' })).toBeDisabled();
+  });
+
+  it('does not save a breakdown that is just the whole word as one morpheme on Enter', async () => {
+    const onSave = jest.fn();
+    renderPopover({ initialValue: 'word', onSave, surfaceText: 'word' });
+    await userEvent.keyboard('{Enter}');
+    expect(onSave).not.toHaveBeenCalled();
+  });
+
+  it('does not render a Delete button when onDelete is not provided', () => {
+    renderPopover();
+    expect(screen.queryByRole('button', { name: 'Delete' })).not.toBeInTheDocument();
+  });
+
+  it('calls onDelete and onClose without saving when Delete is clicked', async () => {
+    const onDelete = jest.fn();
+    const onSave = jest.fn();
+    const onClose = jest.fn();
+    renderPopover({
+      initialValue: 'un- believe',
+      onSave,
+      onClose,
+      onDelete,
+      surfaceText: 'unbelieve',
+    });
+    await userEvent.click(screen.getByRole('button', { name: 'Delete' }));
+    expect(onDelete).toHaveBeenCalledTimes(1);
+    expect(onClose).toHaveBeenCalledTimes(1);
+    expect(onSave).not.toHaveBeenCalled();
+  });
+
+  it('renders inside the popover content panel', () => {
+    // Positioning, portaling, and flipping are owned by the platform-bible-react Popover; this
+    // only verifies the editor renders as the popover's content.
+    renderPopover();
+    const content = screen.getByTestId('popover-content');
+    expect(content).toContainElement(screen.getByText('Split into morphemes'));
+  });
+
+  it('focuses the first morpheme gloss field of the chip when the popover closes', async () => {
+    // The chip label holds the morpheme gloss inputs before the token gloss input; on close, focus
+    // should land on the first morpheme gloss, scoped to this token's label via glossInputId.
+    render(
+      <label>
+        <input aria-label="morpheme gloss" data-morpheme-gloss="true" />
+        <input aria-label="token gloss" id="gloss-1" />
+        <MorphemeBreakdownPopover
+          glossInputId="gloss-1"
+          initialValue="word"
+          onClose={jest.fn()}
+          onSave={jest.fn()}
+          surfaceText="word"
+        />
+      </label>,
+    );
+    await userEvent.click(screen.getByTestId('popover-close'));
+    expect(screen.getByRole('textbox', { name: 'morpheme gloss' })).toHaveFocus();
+  });
+
+  it('falls back to the token gloss input on close when the chip has no morpheme gloss field', async () => {
+    render(
+      <label>
+        <input aria-label="token gloss" id="gloss-1" />
+        <MorphemeBreakdownPopover
+          glossInputId="gloss-1"
+          initialValue="word"
+          onClose={jest.fn()}
+          onSave={jest.fn()}
+          surfaceText="word"
+        />
+      </label>,
+    );
+    await userEvent.click(screen.getByTestId('popover-close'));
+    expect(screen.getByRole('textbox', { name: 'token gloss' })).toHaveFocus();
+  });
+});
+
+describe('MorphemeGlossInput', () => {
+  it('renders an empty input when no gloss exists', () => {
+    render(
+      <MorphemeGlossInput
+        morpheme={{ id: 'm-1', form: 'un-', writingSystem: 'und' }}
+        tokenRef="tok-1"
+        analysisLanguage="und"
+        disabled={false}
+      />,
+    );
+    expect(screen.getByRole('textbox', { name: 'Gloss for morpheme un-' })).toHaveValue('');
+  });
+
+  it('renders the existing gloss value', () => {
+    render(
+      <MorphemeGlossInput
+        morpheme={{ id: 'm-1', form: 'un-', writingSystem: 'und', gloss: { und: 'not' } }}
+        tokenRef="tok-1"
+        analysisLanguage="und"
+        disabled={false}
+      />,
+    );
+    expect(screen.getByRole('textbox', { name: 'Gloss for morpheme un-' })).toHaveValue('not');
+  });
+
+  it('does not dispatch when blurring without changes', async () => {
+    const dispatchMock = jest.fn();
+    jest.spyOn(AnalysisStore, 'useMorphemeGlossDispatch').mockReturnValue(dispatchMock);
+
+    render(
+      <MorphemeGlossInput
+        morpheme={{ id: 'm-1', form: 'un-', writingSystem: 'und', gloss: { und: 'not' } }}
+        tokenRef="tok-1"
+        analysisLanguage="und"
+        disabled={false}
+      />,
+    );
+    await userEvent.click(screen.getByRole('textbox', { name: 'Gloss for morpheme un-' }));
+    await userEvent.tab();
+    expect(dispatchMock).not.toHaveBeenCalled();
+  });
+
+  it('dispatches the gloss on blur when the draft differs', async () => {
+    const dispatchMock = jest.fn();
+    jest.spyOn(AnalysisStore, 'useMorphemeGlossDispatch').mockReturnValue(dispatchMock);
+
+    render(
+      <MorphemeGlossInput
+        morpheme={{ id: 'm-1', form: 'un-', writingSystem: 'und' }}
+        tokenRef="tok-1"
+        analysisLanguage="und"
+        disabled={false}
+      />,
+    );
+    await userEvent.type(screen.getByRole('textbox', { name: 'Gloss for morpheme un-' }), 'not');
+    await userEvent.tab();
+    expect(dispatchMock).toHaveBeenCalledWith('tok-1', 'm-1', 'not');
+  });
+
+  it('does not dispatch when disabled', async () => {
+    const dispatchMock = jest.fn();
+    jest.spyOn(AnalysisStore, 'useMorphemeGlossDispatch').mockReturnValue(dispatchMock);
+
+    render(
+      <MorphemeGlossInput
+        morpheme={{ id: 'm-1', form: 'un-', writingSystem: 'und' }}
+        tokenRef="tok-1"
+        analysisLanguage="und"
+        disabled
+      />,
+    );
+    const input = screen.getByRole('textbox', { name: 'Gloss for morpheme un-' });
+    expect(input).toBeDisabled();
+  });
+});
diff --git a/src/__tests__/components/PhraseBox.test.tsx b/src/__tests__/components/PhraseBox.test.tsx
index 4d6c6193..6cb241eb 100644
--- a/src/__tests__/components/PhraseBox.test.tsx
+++ b/src/__tests__/components/PhraseBox.test.tsx
@@ -58,6 +58,10 @@ jest.mock('../../components/TokenChip', () => {
    * @param props.token - The word token to render.
    * @param props.isSplitFree - When true, marks the chip as a would-be-free token.
    * @param props.onRemove - Called when the remove button is clicked; omitted for edge tokens.
+   * @param props.showMorphology - Exposed as a data attribute so tests can verify every PhraseBox
+   *   render path forwards the strip-wide morphology toggle. When true, also renders a
+   *   `data-morpheme-gloss` input before the main gloss input, mirroring the real chip's DOM order
+   *   so focus-routing tests exercise the morpheme-exclusion selector.
    * @returns A span containing the surface text, a gloss input, and an optional remove button.
    */
   function MockTokenChip({
@@ -65,17 +69,29 @@ jest.mock('../../components/TokenChip', () => {
     token,
     isSplitFree,
     onRemove,
+    showMorphology,
   }: Readonly<{
     onFocus?: () => void;
     token: Token;
     isSplitFree?: boolean;
     onRemove?: () => void;
+    showMorphology?: boolean;
   }>) {
     const gloss = mockUseGloss(token.ref);
     const dispatch = mockUseGlossDispatch();
     return (
-      <span data-testid={`token-${token.ref}`} data-split-free={isSplitFree ? 'true' : 'false'}>
+      <span
+        data-testid={`token-${token.ref}`}
+        data-split-free={isSplitFree ? 'true' : 'false'}
+        data-show-morphology={showMorphology ? 'true' : 'false'}
+      >
         {token.surfaceText}
+        {showMorphology && (
+          <input
+            aria-label={`Gloss for morpheme ${token.surfaceText}`}
+            data-morpheme-gloss="true"
+          />
+        )}
         <input
           aria-label={`Gloss for ${token.surfaceText}`}
           onChange={(e) => dispatch(token.ref, token.surfaceText, e.target.value)}
@@ -292,6 +308,38 @@ describe('PhraseBox', () => {
     expect(onFocusPhrase).toHaveBeenCalledWith('test-group');
   });
 
+  it('clicking the box with morphology shown focuses the token gloss input, not the preceding morpheme gloss input', async () => {
+    const onFocusPhrase = jest.fn();
+    renderBox(
+      <PhraseBox
+        {...requiredProps()}
+        onFocusPhrase={onFocusPhrase}
+        tokens={[TEST_TOKEN, TEST_TOKEN_2]}
+      />,
+      { showMorphology: true },
+    );
+
+    const phraseBox = document.querySelector('[data-phrase-box="true"]');
+    await userEvent.click(phraseBox ?? document.body);
+
+    // Morpheme gloss inputs precede the token gloss input in DOM order; the box-click handler must
+    // skip them — only the token gloss input fires onFocus → onFocusPhrase.
+    expect(screen.getByRole('textbox', { name: 'Gloss for Hello' })).toHaveFocus();
+    expect(onFocusPhrase).toHaveBeenCalledWith('test-group');
+  });
+
+  it('Enter on the box container with morphology shown focuses the token gloss input, not the morpheme gloss input', async () => {
+    renderBox(<PhraseBox {...requiredProps()} />, { showMorphology: true });
+
+    const box = document.querySelector('[data-phrase-box="true"]');
+    expect(box).not.toBeNull();
+    if (box instanceof HTMLElement) box.focus();
+    await userEvent.keyboard('{Enter}');
+
+    expect(screen.getByRole('textbox', { name: 'Gloss for Hello' })).toHaveFocus();
+    expect(screen.getByRole('textbox', { name: 'Gloss for morpheme Hello' })).not.toHaveFocus();
+  });
+
   it('applies focused border and background when isFocused is true', () => {
     renderBox(<PhraseBox {...requiredProps()} isFocused />);
 
@@ -511,6 +559,21 @@ describe('PhraseBox', () => {
     expect(screen.getByTestId('inert-punct-1')).toBeInTheDocument();
   });
 
+  it('forwards showMorphology to chips in a non-edit-target box during edit mode', () => {
+    renderBox(
+      <PhraseBox {...requiredProps()} tokens={[TEST_TOKEN, TEST_TOKEN_2]} />,
+      // Edit mode is active for a different phrase, so this free box renders via the fallback
+      // path; its chips must keep their morpheme rows rather than collapsing while editing.
+      {
+        phraseMode: { kind: 'edit', phraseId: 'other-phrase', originalTokens: [] },
+        showMorphology: true,
+      },
+    );
+
+    expect(screen.getByTestId('token-token-1')).toHaveAttribute('data-show-morphology', 'true');
+    expect(screen.getByTestId('token-token-2')).toHaveAttribute('data-show-morphology', 'true');
+  });
+
   it('renders punctuation between tokens in confirm-unlink mode', () => {
     mockUsePhraseLinkForToken.mockReturnValue(TEST_PHRASE_LINK);
     renderBox(
diff --git a/src/__tests__/components/SegmentView.test.tsx b/src/__tests__/components/SegmentView.test.tsx
index cf560a30..a68f719f 100644
--- a/src/__tests__/components/SegmentView.test.tsx
+++ b/src/__tests__/components/SegmentView.test.tsx
@@ -10,6 +10,7 @@ import type { ReactNode } from 'react';
 import type { PhraseDispatch } from '../../components/AnalysisStore';
 import { LINK_SLOT_TRANSITION_MS } from '../../components/PhraseStripParts';
 import { SegmentView } from '../../components/SegmentView';
+import type { ViewOptions } from '../../types/view-options';
 import { makePhraseLink } from '../test-helpers';
 import { withAnalysisStore } from './test-helpers';
 
@@ -190,9 +191,7 @@ function requiredProps(): {
   tokenSegmentMap: ReadonlyMap<string, string>;
   tokenDocOrder: ReadonlyMap<string, number>;
   wordTokenByRef: ReadonlyMap<string, Token & { type: 'word' }>;
-  hideInactiveLinkButtons: boolean;
-  simplifyPhrases: boolean;
-  chapterLabelInVerse: boolean;
+  viewOptions: ViewOptions;
 } {
   return {
     displayMode: 'token-chip',
@@ -208,9 +207,12 @@ function requiredProps(): {
     tokenSegmentMap: new Map(),
     tokenDocOrder: new Map(),
     wordTokenByRef: new Map(),
-    hideInactiveLinkButtons: false,
-    simplifyPhrases: false,
-    chapterLabelInVerse: false,
+    viewOptions: {
+      hideInactiveLinkButtons: false,
+      simplifyPhrases: false,
+      chapterLabelInVerse: false,
+      showMorphology: false,
+    },
   };
 }
 
@@ -272,7 +274,13 @@ describe('SegmentView', () => {
   });
 
   it('folds the chapter into the verse label when chapterLabelInVerse is set', () => {
-    render(<SegmentView {...requiredProps()} chapterLabelInVerse />, withAnalysisStore);
+    render(
+      <SegmentView
+        {...requiredProps()}
+        viewOptions={{ ...requiredProps().viewOptions, chapterLabelInVerse: true }}
+      />,
+      withAnalysisStore,
+    );
 
     expect(screen.getByText('1:1')).toBeInTheDocument();
   });
@@ -281,7 +289,12 @@ describe('SegmentView', () => {
     const { rerender } = render(<SegmentView {...requiredProps()} />, withAnalysisStore);
     expect(screen.queryByText('Chapter 1')).not.toBeInTheDocument();
 
-    rerender(<SegmentView {...requiredProps()} chapterLabelInVerse />);
+    rerender(
+      <SegmentView
+        {...requiredProps()}
+        viewOptions={{ ...requiredProps().viewOptions, chapterLabelInVerse: true }}
+      />,
+    );
     expect(screen.queryByText('Chapter 1')).not.toBeInTheDocument();
   });
 
@@ -576,7 +589,11 @@ describe('SegmentView', () => {
       // its link button to zero width, leaving an empty clickable gap. Clicking that gap must NOT
       // snap focus to the segment's first phrase (the reported out-of-segment bug); it should be a
       // no-op, matching the buttons-visible case where the button absorbs it.
-      <SegmentView {...requiredProps()} hideInactiveLinkButtons onSelect={handleSelect} />,
+      <SegmentView
+        {...requiredProps()}
+        viewOptions={{ ...requiredProps().viewOptions, hideInactiveLinkButtons: true }}
+        onSelect={handleSelect}
+      />,
       withAnalysisStore,
     );
 
diff --git a/src/__tests__/components/TokenChip.test.tsx b/src/__tests__/components/TokenChip.test.tsx
index 98a868b7..89c431d6 100644
--- a/src/__tests__/components/TokenChip.test.tsx
+++ b/src/__tests__/components/TokenChip.test.tsx
@@ -2,14 +2,65 @@
 /// <reference types="jest" />
 /// <reference types="@testing-library/jest-dom" />
 
+import { useLocalizedStrings } from '@papi/frontend/react';
 import { fireEvent, render, screen } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import type { AssignmentStatus, Token, TokenSnapshot } from 'interlinearizer';
+import * as AnalysisStore from '../../components/AnalysisStore';
 import { AnalysisStoreProvider } from '../../components/AnalysisStore';
 import { InertTokenChip, TokenChip } from '../../components/TokenChip';
 
 jest.mock('../../components/AnalysisStore');
 
+const LOCALIZED = {
+  '%interlinearizer_tokenChip_editMorphemes%': 'Edit morpheme breakdown for {token}',
+  '%interlinearizer_tokenChip_defineMorphemes%': 'Define morpheme breakdown for {token}',
+};
+
+beforeEach(() => {
+  jest.mocked(useLocalizedStrings).mockReturnValue([LOCALIZED, false]);
+});
+jest.mock('../../components/MorphemeEditor', () => ({
+  /**
+   * Stub popover that renders a save button so tests can trigger onSave.
+   *
+   * @param props - Receives the same props as the real popover.
+   * @returns A test stub element with a save button.
+   */
+  MorphemeBreakdownPopover({
+    onSave,
+    onClose,
+    onDelete,
+  }: Readonly<{ onSave: (v: string) => void; onClose: () => void; onDelete?: () => void }>) {
+    return (
+      <div data-testid="morpheme-popover">
+        <button onClick={() => onSave('hel -lo')} type="button">
+          mock-save
+        </button>
+        <button onClick={() => onSave('   ')} type="button">
+          mock-save-empty
+        </button>
+        <button onClick={onClose} type="button">
+          mock-close
+        </button>
+        {onDelete && (
+          <button onClick={onDelete} type="button">
+            mock-delete
+          </button>
+        )}
+      </div>
+    );
+  },
+  /**
+   * Stub gloss input that renders a placeholder for test assertions.
+   *
+   * @returns A test stub element.
+   */
+  MorphemeGlossInput() {
+    return <input data-testid="morpheme-gloss" />;
+  },
+}));
+
 const WORD_TOKEN = {
   ref: 'GEN 1:1:0',
   surfaceText: 'hello',
@@ -308,4 +359,273 @@ describe('TokenChip', () => {
     const label = screen.getByText('hello').closest('label');
     expect(label?.className).not.toContain('tw:border-destructive');
   });
+
+  describe('morphology UI', () => {
+    it('does not render morpheme row when showMorphology is false', () => {
+      render(
+        <AnalysisStoreProvider analysisLanguage="und">
+          <TokenChip {...requiredProps()} showMorphology={false} />
+        </AnalysisStoreProvider>,
+      );
+      expect(
+        screen.queryByRole('button', { name: 'Define morpheme breakdown for hello' }),
+      ).not.toBeInTheDocument();
+    });
+
+    it('renders a "define" button when showMorphology is true and no morphemes exist', () => {
+      render(
+        <AnalysisStoreProvider analysisLanguage="und">
+          <TokenChip {...requiredProps()} showMorphology />
+        </AnalysisStoreProvider>,
+      );
+      expect(
+        screen.getByRole('button', { name: 'Define morpheme breakdown for hello' }),
+      ).toBeInTheDocument();
+    });
+
+    it('shows surface text on the define button for unanalyzed tokens', () => {
+      render(
+        <AnalysisStoreProvider analysisLanguage="und">
+          <TokenChip {...requiredProps()} showMorphology />
+        </AnalysisStoreProvider>,
+      );
+      const btn = screen.getByRole('button', { name: 'Define morpheme breakdown for hello' });
+      expect(btn).toHaveTextContent('hello');
+    });
+
+    it('opens the popover when the define button is clicked', async () => {
+      render(
+        <AnalysisStoreProvider analysisLanguage="und">
+          <TokenChip {...requiredProps()} showMorphology />
+        </AnalysisStoreProvider>,
+      );
+      expect(screen.queryByTestId('morpheme-popover')).not.toBeInTheDocument();
+      await userEvent.click(
+        screen.getByRole('button', { name: 'Define morpheme breakdown for hello' }),
+      );
+      expect(screen.getByTestId('morpheme-popover')).toBeInTheDocument();
+    });
+
+    it('does not open the popover when disabled', async () => {
+      render(
+        <AnalysisStoreProvider analysisLanguage="und">
+          <TokenChip {...requiredProps()} showMorphology disabled />
+        </AnalysisStoreProvider>,
+      );
+      await userEvent.click(
+        screen.getByRole('button', { name: 'Define morpheme breakdown for hello' }),
+      );
+      expect(screen.queryByTestId('morpheme-popover')).not.toBeInTheDocument();
+    });
+
+    it('renders morpheme forms when morphemes exist', () => {
+      // AnalysisStore imported at top level
+      jest.spyOn(AnalysisStore, 'useMorphemes').mockReturnValue([
+        { id: 'm-1', form: 'hel', writingSystem: 'und' },
+        { id: 'm-2', form: '-lo', writingSystem: 'und' },
+      ]);
+      render(
+        <AnalysisStoreProvider analysisLanguage="und">
+          <TokenChip {...requiredProps()} showMorphology />
+        </AnalysisStoreProvider>,
+      );
+      expect(
+        screen.getByRole('button', { name: 'Edit morpheme breakdown for hello' }),
+      ).toBeInTheDocument();
+      expect(screen.getByText('hel')).toBeInTheDocument();
+      expect(screen.getByText('-lo')).toBeInTheDocument();
+    });
+
+    it('renders morpheme gloss inputs when morphemes exist', () => {
+      // AnalysisStore imported at top level
+      jest.spyOn(AnalysisStore, 'useMorphemes').mockReturnValue([
+        { id: 'm-1', form: 'hel', writingSystem: 'und' },
+        { id: 'm-2', form: '-lo', writingSystem: 'und' },
+      ]);
+      render(
+        <AnalysisStoreProvider analysisLanguage="und">
+          <TokenChip {...requiredProps()} showMorphology />
+        </AnalysisStoreProvider>,
+      );
+      expect(screen.getAllByTestId('morpheme-gloss')).toHaveLength(2);
+    });
+
+    it('opens the popover when the edit button is clicked on analyzed token', async () => {
+      // AnalysisStore imported at top level
+      jest
+        .spyOn(AnalysisStore, 'useMorphemes')
+        .mockReturnValue([{ id: 'm-1', form: 'hel', writingSystem: 'und' }]);
+      render(
+        <AnalysisStoreProvider analysisLanguage="und">
+          <TokenChip {...requiredProps()} showMorphology />
+        </AnalysisStoreProvider>,
+      );
+      await userEvent.click(
+        screen.getByRole('button', { name: 'Edit morpheme breakdown for hello' }),
+      );
+      expect(screen.getByTestId('morpheme-popover')).toBeInTheDocument();
+    });
+
+    it('dispatches morpheme breakdown when saving from the popover', async () => {
+      const mockDispatch = jest.fn();
+      // AnalysisStore imported at top level
+      jest.spyOn(AnalysisStore, 'useMorphemeBreakdownDispatch').mockReturnValue(mockDispatch);
+
+      render(
+        <AnalysisStoreProvider analysisLanguage="und">
+          <TokenChip {...requiredProps()} showMorphology />
+        </AnalysisStoreProvider>,
+      );
+      await userEvent.click(
+        screen.getByRole('button', { name: 'Define morpheme breakdown for hello' }),
+      );
+      await userEvent.click(screen.getByRole('button', { name: 'mock-save' }));
+      expect(mockDispatch).toHaveBeenCalledWith('GEN 1:1:0', 'hello', ['hel', '-lo'], 'en');
+    });
+
+    it('does not dispatch when the popover saves only whitespace', async () => {
+      const mockDispatch = jest.fn();
+      // AnalysisStore imported at top level
+      jest.spyOn(AnalysisStore, 'useMorphemeBreakdownDispatch').mockReturnValue(mockDispatch);
+
+      render(
+        <AnalysisStoreProvider analysisLanguage="und">
+          <TokenChip {...requiredProps()} showMorphology />
+        </AnalysisStoreProvider>,
+      );
+      await userEvent.click(
+        screen.getByRole('button', { name: 'Define morpheme breakdown for hello' }),
+      );
+      await userEvent.click(screen.getByRole('button', { name: 'mock-save-empty' }));
+      expect(mockDispatch).not.toHaveBeenCalled();
+    });
+
+    it('dispatches morpheme deletion when the popover delete is clicked', async () => {
+      const mockDispatch = jest.fn();
+      // AnalysisStore imported at top level
+      jest
+        .spyOn(AnalysisStore, 'useMorphemes')
+        .mockReturnValue([{ id: 'm-1', form: 'hel', writingSystem: 'und' }]);
+      jest.spyOn(AnalysisStore, 'useMorphemeDeleteDispatch').mockReturnValue(mockDispatch);
+
+      render(
+        <AnalysisStoreProvider analysisLanguage="und">
+          <TokenChip {...requiredProps()} showMorphology />
+        </AnalysisStoreProvider>,
+      );
+      await userEvent.click(
+        screen.getByRole('button', { name: 'Edit morpheme breakdown for hello' }),
+      );
+      await userEvent.click(screen.getByRole('button', { name: 'mock-delete' }));
+      expect(mockDispatch).toHaveBeenCalledWith('GEN 1:1:0');
+    });
+
+    it('passes no onDelete to the popover when the token has no breakdown', async () => {
+      render(
+        <AnalysisStoreProvider analysisLanguage="und">
+          <TokenChip {...requiredProps()} showMorphology />
+        </AnalysisStoreProvider>,
+      );
+      await userEvent.click(
+        screen.getByRole('button', { name: 'Define morpheme breakdown for hello' }),
+      );
+      expect(screen.getByTestId('morpheme-popover')).toBeInTheDocument();
+      expect(screen.queryByRole('button', { name: 'mock-delete' })).not.toBeInTheDocument();
+    });
+
+    it('focuses the main gloss input on a surface-text mouse-down when morpheme inputs precede it', () => {
+      // AnalysisStore imported at top level
+      jest
+        .spyOn(AnalysisStore, 'useMorphemes')
+        .mockReturnValue([{ id: 'm-1', form: 'hel', writingSystem: 'und' }]);
+      render(
+        <AnalysisStoreProvider analysisLanguage="und">
+          <TokenChip {...requiredProps()} showMorphology />
+        </AnalysisStoreProvider>,
+      );
+
+      // The morpheme gloss inputs sit before the main gloss input inside the label; the label
+      // handler must still route focus to the main gloss input, not the first input it finds.
+      fireEvent.mouseDown(screen.getByText('hello'));
+
+      expect(screen.getByRole('textbox', { name: 'Gloss for hello' })).toHaveFocus();
+    });
+
+    it('leaves a mouse-down on the morpheme button to the button itself', () => {
+      const focusSpy = jest.spyOn(HTMLElement.prototype, 'focus');
+      render(
+        <AnalysisStoreProvider analysisLanguage="und">
+          <TokenChip {...requiredProps()} showMorphology />
+        </AnalysisStoreProvider>,
+      );
+
+      // The button opens the popover via its own click handler; the label handler must not focus
+      // an input as a side effect of the same mouse-down.
+      const defaultAllowed = fireEvent.mouseDown(
+        screen.getByRole('button', { name: 'Define morpheme breakdown for hello' }),
+      );
+
+      expect(defaultAllowed).toBe(true);
+      expect(focusSpy).not.toHaveBeenCalled();
+    });
+
+    it('does not reopen the popover when showMorphology is toggled off and back on', async () => {
+      const { rerender } = render(
+        <AnalysisStoreProvider analysisLanguage="und">
+          <TokenChip {...requiredProps()} showMorphology />
+        </AnalysisStoreProvider>,
+      );
+      await userEvent.click(
+        screen.getByRole('button', { name: 'Define morpheme breakdown for hello' }),
+      );
+      expect(screen.getByTestId('morpheme-popover')).toBeInTheDocument();
+      // Toggling morphology off unmounts the popover tree; the open state must not survive and
+      // resurrect the popover when morphology comes back.
+      rerender(
+        <AnalysisStoreProvider analysisLanguage="und">
+          <TokenChip {...requiredProps()} showMorphology={false} />
+        </AnalysisStoreProvider>,
+      );
+      rerender(
+        <AnalysisStoreProvider analysisLanguage="und">
+          <TokenChip {...requiredProps()} showMorphology />
+        </AnalysisStoreProvider>,
+      );
+      expect(screen.queryByTestId('morpheme-popover')).not.toBeInTheDocument();
+    });
+
+    it('closes the popover when the chip becomes disabled', async () => {
+      const { rerender } = render(
+        <AnalysisStoreProvider analysisLanguage="und">
+          <TokenChip {...requiredProps()} showMorphology />
+        </AnalysisStoreProvider>,
+      );
+      await userEvent.click(
+        screen.getByRole('button', { name: 'Define morpheme breakdown for hello' }),
+      );
+      expect(screen.getByTestId('morpheme-popover')).toBeInTheDocument();
+      // The popover content renders on `popoverOpen` alone, not gated on `disabled`; a chip whose
+      // popover is open while it transitions to disabled would otherwise stay editable.
+      rerender(
+        <AnalysisStoreProvider analysisLanguage="und">
+          <TokenChip {...requiredProps()} showMorphology disabled />
+        </AnalysisStoreProvider>,
+      );
+      expect(screen.queryByTestId('morpheme-popover')).not.toBeInTheDocument();
+    });
+
+    it('closes the popover via onClose', async () => {
+      render(
+        <AnalysisStoreProvider analysisLanguage="und">
+          <TokenChip {...requiredProps()} showMorphology />
+        </AnalysisStoreProvider>,
+      );
+      await userEvent.click(
+        screen.getByRole('button', { name: 'Define morpheme breakdown for hello' }),
+      );
+      expect(screen.getByTestId('morpheme-popover')).toBeInTheDocument();
+      await userEvent.click(screen.getByRole('button', { name: 'mock-close' }));
+      expect(screen.queryByTestId('morpheme-popover')).not.toBeInTheDocument();
+    });
+  });
 });
diff --git a/src/__tests__/components/controls/ViewOptionsDropdown.test.tsx b/src/__tests__/components/controls/ViewOptionsDropdown.test.tsx
index acdec59e..55ca467d 100644
--- a/src/__tests__/components/controls/ViewOptionsDropdown.test.tsx
+++ b/src/__tests__/components/controls/ViewOptionsDropdown.test.tsx
@@ -27,6 +27,8 @@ const DEFAULT_PROPS = {
   onSimplifyPhrasesChange: jest.fn(),
   chapterLabelInVerse: false,
   onChapterLabelInVerseChange: jest.fn(),
+  showMorphology: false,
+  onShowMorphologyChange: jest.fn(),
 };
 
 describe('ViewOptionsDropdown', () => {
@@ -144,13 +146,38 @@ describe('ViewOptionsDropdown', () => {
     });
   });
 
+  describe('show morphology toggle', () => {
+    it('reflects the checked value', async () => {
+      render(<ViewOptionsDropdown {...DEFAULT_PROPS} showMorphology />);
+      await userEvent.click(screen.getByTestId('view-options-button'));
+
+      expect(screen.getByRole('checkbox', { name: /morphology/i })).toBeChecked();
+    });
+
+    it('calls onShowMorphologyChange when toggled', async () => {
+      const onShowMorphologyChange = jest.fn();
+      render(
+        <ViewOptionsDropdown
+          {...DEFAULT_PROPS}
+          showMorphology={false}
+          onShowMorphologyChange={onShowMorphologyChange}
+        />,
+      );
+      await userEvent.click(screen.getByTestId('view-options-button'));
+
+      await userEvent.click(screen.getByRole('checkbox', { name: /morphology/i }));
+
+      expect(onShowMorphologyChange).toHaveBeenCalledWith(true);
+    });
+  });
+
   describe('hide inactive link buttons toggle', () => {
     it('reflects the checked value', async () => {
       render(<ViewOptionsDropdown {...DEFAULT_PROPS} hideInactiveLinkButtons />);
       await userEvent.click(screen.getByTestId('view-options-button'));
 
       const checkboxes = screen.getAllByRole('checkbox');
-      expect(checkboxes[1]).toBeChecked();
+      expect(checkboxes[2]).toBeChecked();
     });
 
     it('calls onHideInactiveLinkButtonsChange when toggled', async () => {
@@ -165,7 +192,7 @@ describe('ViewOptionsDropdown', () => {
       await userEvent.click(screen.getByTestId('view-options-button'));
 
       const checkboxes = screen.getAllByRole('checkbox');
-      await userEvent.click(checkboxes[1]);
+      await userEvent.click(checkboxes[2]);
 
       expect(onHideInactiveLinkButtonsChange).toHaveBeenCalledWith(true);
     });
@@ -177,7 +204,7 @@ describe('ViewOptionsDropdown', () => {
       await userEvent.click(screen.getByTestId('view-options-button'));
 
       const checkboxes = screen.getAllByRole('checkbox');
-      expect(checkboxes[2]).toBeChecked();
+      expect(checkboxes[3]).toBeChecked();
     });
 
     it('calls onSimplifyPhrasesChange when toggled', async () => {
@@ -192,7 +219,7 @@ describe('ViewOptionsDropdown', () => {
       await userEvent.click(screen.getByTestId('view-options-button'));
 
       const checkboxes = screen.getAllByRole('checkbox');
-      await userEvent.click(checkboxes[2]);
+      await userEvent.click(checkboxes[3]);
 
       expect(onSimplifyPhrasesChange).toHaveBeenCalledWith(true);
     });
@@ -204,7 +231,7 @@ describe('ViewOptionsDropdown', () => {
       await userEvent.click(screen.getByTestId('view-options-button'));
 
       const checkboxes = screen.getAllByRole('checkbox');
-      expect(checkboxes[3]).toBeChecked();
+      expect(checkboxes[4]).toBeChecked();
     });
 
     it('calls onChapterLabelInVerseChange when toggled', async () => {
@@ -219,7 +246,7 @@ describe('ViewOptionsDropdown', () => {
       await userEvent.click(screen.getByTestId('view-options-button'));
 
       const checkboxes = screen.getAllByRole('checkbox');
-      await userEvent.click(checkboxes[3]);
+      await userEvent.click(checkboxes[4]);
 
       expect(onChapterLabelInVerseChange).toHaveBeenCalledWith(true);
     });
diff --git a/src/__tests__/main.test.ts b/src/__tests__/main.test.ts
index 78a9259d..8eab3912 100644
--- a/src/__tests__/main.test.ts
+++ b/src/__tests__/main.test.ts
@@ -264,7 +264,7 @@ describe('main', () => {
 
       await activate(context);
 
-      expect(context.registrations.unsubscribers.size).toBe(17);
+      expect(context.registrations.unsubscribers.size).toBe(18);
     });
 
     it('logs activation start and finish', async () => {
diff --git a/src/__tests__/store/analysisSlice.test.ts b/src/__tests__/store/analysisSlice.test.ts
index 74e8360a..02cf794b 100644
--- a/src/__tests__/store/analysisSlice.test.ts
+++ b/src/__tests__/store/analysisSlice.test.ts
@@ -14,9 +14,11 @@ import { emptyAnalysis } from '../../types/empty-factories';
 import {
   createPhrase,
   defaultState,
+  deleteMorphemes,
   deletePhrase,
   mergePhrases,
   selectApprovedGloss,
+  selectApprovedMorphemes,
   selectPhraseLinkByTokenRef,
   selectPhraseAnalysisById,
   selectPhraseGloss,
@@ -24,6 +26,8 @@ import {
   setAnalysis,
   updatePhrase,
   writeGloss,
+  writeMorphemeGloss,
+  writeMorphemes,
   writePhraseGloss,
 } from '../../store/analysisSlice';
 
@@ -131,6 +135,88 @@ describe('writeGloss', () => {
     const { tokenAnalyses } = store.getState().analysis.analysis;
     expect(tokenAnalyses[0].gloss).toStrictEqual({ und: 'hello' });
   });
+
+  it('refreshes the surface text on the analysis and the link snapshot when the token text changed', () => {
+    const store = createAnalysisStore({
+      analysis: {
+        analysis: makeAnalysis({ id: 'ta-1', surfaceText: 'word', gloss: { und: 'hi' } }),
+        analysisLanguage: 'und',
+      },
+    });
+
+    store.dispatch(writeGloss('tok-1', 'words', 'hello'));
+
+    const { tokenAnalyses, tokenAnalysisLinks } = store.getState().analysis.analysis;
+    expect(tokenAnalyses[0].surfaceText).toBe('words');
+    expect(tokenAnalysisLinks[0].token.surfaceText).toBe('words');
+  });
+
+  it('removes the record and link when a blank gloss empties a gloss-only analysis', () => {
+    const store = createAnalysisStore({
+      analysis: {
+        analysis: makeAnalysis({ id: 'ta-1', surfaceText: 'word', gloss: { und: 'hi' } }),
+        analysisLanguage: 'und',
+      },
+    });
+
+    store.dispatch(writeGloss('tok-1', 'word', '   '));
+
+    const { tokenAnalyses, tokenAnalysisLinks } = store.getState().analysis.analysis;
+    expect(tokenAnalyses).toHaveLength(0);
+    expect(tokenAnalysisLinks).toHaveLength(0);
+  });
+
+  it('clears the active-language gloss but keeps the record when other content remains', () => {
+    const store = createAnalysisStore({
+      analysis: {
+        analysis: makeAnalysis({
+          id: 'ta-1',
+          surfaceText: 'word',
+          gloss: { und: 'hi' },
+          morphemes: [{ id: 'm-1', form: 'word', writingSystem: 'und' }],
+        }),
+        analysisLanguage: 'und',
+      },
+    });
+
+    store.dispatch(writeGloss('tok-1', 'word', ''));
+
+    const { tokenAnalyses } = store.getState().analysis.analysis;
+    expect(tokenAnalyses).toHaveLength(1);
+    expect(tokenAnalyses[0].gloss).toBeUndefined();
+    expect(tokenAnalyses[0].morphemes).toHaveLength(1);
+  });
+
+  it('clears only the active-language gloss when another language gloss remains', () => {
+    const store = createAnalysisStore({
+      analysis: {
+        analysis: makeAnalysis({
+          id: 'ta-1',
+          surfaceText: 'word',
+          gloss: { und: 'hi', fr: 'bonjour' },
+        }),
+        analysisLanguage: 'und',
+      },
+    });
+
+    store.dispatch(writeGloss('tok-1', 'word', ''));
+
+    const { tokenAnalyses } = store.getState().analysis.analysis;
+    expect(tokenAnalyses).toHaveLength(1);
+    expect(tokenAnalyses[0].gloss).toStrictEqual({ fr: 'bonjour' });
+  });
+
+  it('is a no-op when a blank gloss is written to a token with no approved analysis', () => {
+    const store = createAnalysisStore({
+      analysis: { analysis: emptyAnalysis(), analysisLanguage: 'und' },
+    });
+
+    store.dispatch(writeGloss('tok-1', 'word', '  '));
+
+    const { tokenAnalyses, tokenAnalysisLinks } = store.getState().analysis.analysis;
+    expect(tokenAnalyses).toHaveLength(0);
+    expect(tokenAnalysisLinks).toHaveLength(0);
+  });
 });
 
 describe('selectApprovedGloss', () => {
@@ -544,3 +630,532 @@ describe('selectPhraseGloss', () => {
     expect(selectPhraseGloss(store.getState().analysis, 'nonexistent')).toBe('');
   });
 });
+
+describe('writeMorphemes', () => {
+  it('creates a new approved analysis with morphemes when none exists', () => {
+    const store = createAnalysisStore();
+    store.dispatch(writeMorphemes('tok-1', 'unbelievable', ['un-', 'believe', '-able'], 'und'));
+
+    const { tokenAnalyses, tokenAnalysisLinks } = store.getState().analysis.analysis;
+    expect(tokenAnalysisLinks).toHaveLength(1);
+    expect(tokenAnalysisLinks[0].status).toBe('approved');
+    expect(tokenAnalysisLinks[0].token.tokenRef).toBe('tok-1');
+
+    const ta = tokenAnalyses.find((a) => a.id === tokenAnalysisLinks[0].analysisId);
+    expect(ta).toBeDefined();
+    expect(ta?.morphemes).toHaveLength(3);
+    expect(ta?.morphemes?.[0].form).toBe('un-');
+    expect(ta?.morphemes?.[1].form).toBe('believe');
+    expect(ta?.morphemes?.[2].form).toBe('-able');
+  });
+
+  it('updates morphemes on an existing approved analysis, preserving glosses by form', () => {
+    const ta: TokenAnalysis = {
+      id: 'ta-1',
+      surfaceText: 'unbelievable',
+      morphemes: [
+        { id: 'm-1', form: 'un-', writingSystem: 'und', gloss: { und: 'not' } },
+        { id: 'm-2', form: 'believe', writingSystem: 'und', gloss: { und: 'trust' } },
+        { id: 'm-3', form: '-able', writingSystem: 'und' },
+      ],
+    };
+    const store = createAnalysisStore({
+      analysis: { analysis: makeAnalysis(ta), analysisLanguage: 'und' },
+    });
+
+    store.dispatch(writeMorphemes('tok-1', 'unbelievable', ['un-', 'believ', '-able'], 'und'));
+
+    const updated = store
+      .getState()
+      .analysis.analysis.tokenAnalyses.find(
+        (a) =>
+          a.id ===
+          store
+            .getState()
+            .analysis.analysis.tokenAnalysisLinks.find(
+              (l) => l.status === 'approved' && l.token.tokenRef === 'tok-1',
+            )?.analysisId,
+      );
+    expect(updated?.morphemes).toHaveLength(3);
+    expect(updated?.morphemes?.[0].gloss).toStrictEqual({ und: 'not' });
+    expect(updated?.morphemes?.[1].gloss).toBeUndefined();
+    expect(updated?.morphemes?.[2].form).toBe('-able');
+  });
+
+  it('preserves distinct glosses on duplicate morpheme forms in order (reduplication)', () => {
+    const ta: TokenAnalysis = {
+      id: 'ta-1',
+      surfaceText: 'baba',
+      morphemes: [
+        { id: 'm-1', form: 'ba', writingSystem: 'und', gloss: { und: 'first' } },
+        { id: 'm-2', form: 'ba', writingSystem: 'und', gloss: { und: 'second' } },
+      ],
+    };
+    const store = createAnalysisStore({
+      analysis: { analysis: makeAnalysis(ta), analysisLanguage: 'und' },
+    });
+
+    store.dispatch(writeMorphemes('tok-1', 'baba', ['ba', 'ba'], 'und'));
+
+    const updated = store.getState().analysis.analysis.tokenAnalyses.find((a) => a.id === 'ta-1');
+    expect(updated?.morphemes?.[0].gloss).toStrictEqual({ und: 'first' });
+    expect(updated?.morphemes?.[1].gloss).toStrictEqual({ und: 'second' });
+  });
+
+  it('removes an orphaned approved link and creates a fresh analysis', () => {
+    const orphanLink: TokenAnalysisLink = {
+      analysisId: 'old-uuid',
+      status: 'approved',
+      token: { tokenRef: 'tok-1', surfaceText: 'word' },
+    };
+    const store = createAnalysisStore({
+      analysis: {
+        analysis: { ...emptyAnalysis(), tokenAnalysisLinks: [orphanLink] },
+        analysisLanguage: 'und',
+      },
+    });
+
+    store.dispatch(writeMorphemes('tok-1', 'word', ['wor', '-d'], 'und'));
+
+    const { tokenAnalyses, tokenAnalysisLinks } = store.getState().analysis.analysis;
+    expect(tokenAnalysisLinks).toHaveLength(1);
+    expect(tokenAnalysisLinks[0].analysisId).not.toBe('old-uuid');
+
+    const ta = tokenAnalyses.find((a) => a.id === tokenAnalysisLinks[0].analysisId);
+    expect(ta?.morphemes).toHaveLength(2);
+  });
+
+  it('refreshes the surface text on the analysis and the link snapshot when the token text changed', () => {
+    const ta: TokenAnalysis = {
+      id: 'ta-1',
+      surfaceText: 'word',
+      morphemes: [{ id: 'm-1', form: 'word', writingSystem: 'und' }],
+    };
+    const store = createAnalysisStore({
+      analysis: { analysis: makeAnalysis(ta), analysisLanguage: 'und' },
+    });
+
+    store.dispatch(writeMorphemes('tok-1', 'words', ['word', '-s'], 'und'));
+
+    const { tokenAnalyses, tokenAnalysisLinks } = store.getState().analysis.analysis;
+    expect(tokenAnalyses.find((a) => a.id === 'ta-1')?.surfaceText).toBe('words');
+    expect(tokenAnalysisLinks[0].token.surfaceText).toBe('words');
+  });
+
+  it('adds morphemes to an existing approved analysis that has no morphemes', () => {
+    const ta: TokenAnalysis = { id: 'ta-1', surfaceText: 'hello' };
+    const store = createAnalysisStore({
+      analysis: { analysis: makeAnalysis(ta), analysisLanguage: 'und' },
+    });
+
+    store.dispatch(writeMorphemes('tok-1', 'hello', ['hel', '-lo'], 'und'));
+
+    const updated = store.getState().analysis.analysis.tokenAnalyses.find((a) => a.id === 'ta-1');
+    expect(updated?.morphemes).toHaveLength(2);
+    expect(updated?.morphemes?.[0].form).toBe('hel');
+  });
+
+  it('preserves morpheme ids when forms are unchanged', () => {
+    const ta: TokenAnalysis = {
+      id: 'ta-1',
+      surfaceText: 'unbelievable',
+      morphemes: [
+        { id: 'm-1', form: 'un-', writingSystem: 'und' },
+        { id: 'm-2', form: 'believe', writingSystem: 'und' },
+      ],
+    };
+    const store = createAnalysisStore({
+      analysis: { analysis: makeAnalysis(ta), analysisLanguage: 'und' },
+    });
+
+    store.dispatch(writeMorphemes('tok-1', 'unbelievable', ['un-', 'believe', '-able'], 'und'));
+
+    // MorphemeLink.morphemeId cross-references these ids, so editing the breakdown must not
+    // regenerate the ids of morphemes whose form did not change.
+    const updated = store.getState().analysis.analysis.tokenAnalyses.find((a) => a.id === 'ta-1');
+    expect(updated?.morphemes?.[0].id).toBe('m-1');
+    expect(updated?.morphemes?.[1].id).toBe('m-2');
+  });
+
+  it('assigns a fresh id to a newly added morpheme alongside preserved ones', () => {
+    const ta: TokenAnalysis = {
+      id: 'ta-1',
+      surfaceText: 'unbelievable',
+      morphemes: [
+        { id: 'm-1', form: 'un-', writingSystem: 'und' },
+        { id: 'm-2', form: 'believe', writingSystem: 'und' },
+      ],
+    };
+    const store = createAnalysisStore({
+      analysis: { analysis: makeAnalysis(ta), analysisLanguage: 'und' },
+    });
+
+    store.dispatch(writeMorphemes('tok-1', 'unbelievable', ['un-', 'believe', '-able'], 'und'));
+
+    const updated = store.getState().analysis.analysis.tokenAnalyses.find((a) => a.id === 'ta-1');
+    const newId = updated?.morphemes?.[2].id;
+    expect(newId).toBeDefined();
+    expect(newId).not.toBe('m-1');
+    expect(newId).not.toBe('m-2');
+  });
+
+  it('assigns unique ids to each morpheme via prepare', () => {
+    const store = createAnalysisStore();
+    store.dispatch(writeMorphemes('tok-1', 'abc', ['a', 'b', 'c'], 'und'));
+
+    const ta = store.getState().analysis.analysis.tokenAnalyses[0];
+    const ids = ta.morphemes?.map((m) => m.id);
+    expect(new Set(ids).size).toBe(3);
+  });
+
+  it('stores the passed writing system on new morphemes, not the analysis language', () => {
+    const store = createAnalysisStore({
+      analysis: { analysis: emptyAnalysis(), analysisLanguage: 'en' },
+    });
+    store.dispatch(writeMorphemes('tok-1', 'λόγος', ['λόγ', '-ος'], 'grc'));
+
+    const ta = store.getState().analysis.analysis.tokenAnalyses[0];
+    expect(ta.morphemes?.map((m) => m.writingSystem)).toStrictEqual(['grc', 'grc']);
+  });
+
+  it('refreshes the writing system on preserved morphemes whose form is unchanged', () => {
+    const ta: TokenAnalysis = {
+      id: 'ta-1',
+      surfaceText: 'λόγος',
+      morphemes: [{ id: 'm-1', form: 'λόγ', writingSystem: 'en', gloss: { en: 'word' } }],
+    };
+    const store = createAnalysisStore({
+      analysis: { analysis: makeAnalysis(ta), analysisLanguage: 'en' },
+    });
+
+    store.dispatch(writeMorphemes('tok-1', 'λόγος', ['λόγ', '-ος'], 'grc'));
+
+    const updated = store.getState().analysis.analysis.tokenAnalyses.find((a) => a.id === 'ta-1');
+    expect(updated?.morphemes?.[0].gloss).toStrictEqual({ en: 'word' });
+    expect(updated?.morphemes?.[0].writingSystem).toBe('grc');
+  });
+});
+
+describe('deleteMorphemes', () => {
+  it('removes the morphemes but keeps the analysis when it has a gloss', () => {
+    const ta: TokenAnalysis = {
+      id: 'ta-1',
+      surfaceText: 'unbelievable',
+      gloss: { und: 'incredible' },
+      morphemes: [{ id: 'm-1', form: 'un-', writingSystem: 'und' }],
+    };
+    const store = createAnalysisStore({
+      analysis: { analysis: makeAnalysis(ta), analysisLanguage: 'und' },
+    });
+
+    store.dispatch(deleteMorphemes({ tokenRef: 'tok-1' }));
+
+    const { tokenAnalyses, tokenAnalysisLinks } = store.getState().analysis.analysis;
+    expect(tokenAnalyses).toHaveLength(1);
+    expect(tokenAnalyses[0].morphemes).toBeUndefined();
+    expect(tokenAnalyses[0].gloss).toStrictEqual({ und: 'incredible' });
+    expect(tokenAnalysisLinks).toHaveLength(1);
+  });
+
+  it('removes the analysis and its link when it has no gloss', () => {
+    const ta: TokenAnalysis = {
+      id: 'ta-1',
+      surfaceText: 'word',
+      morphemes: [{ id: 'm-1', form: 'word', writingSystem: 'und' }],
+    };
+    const store = createAnalysisStore({
+      analysis: { analysis: makeAnalysis(ta), analysisLanguage: 'und' },
+    });
+
+    store.dispatch(deleteMorphemes({ tokenRef: 'tok-1' }));
+
+    const { tokenAnalyses, tokenAnalysisLinks } = store.getState().analysis.analysis;
+    expect(tokenAnalyses).toHaveLength(0);
+    expect(tokenAnalysisLinks).toHaveLength(0);
+  });
+
+  it('removes the analysis and its link when its gloss object is empty', () => {
+    const ta: TokenAnalysis = {
+      id: 'ta-1',
+      surfaceText: 'word',
+      gloss: {},
+      morphemes: [{ id: 'm-1', form: 'word', writingSystem: 'und' }],
+    };
+    const store = createAnalysisStore({
+      analysis: { analysis: makeAnalysis(ta), analysisLanguage: 'und' },
+    });
+
+    store.dispatch(deleteMorphemes({ tokenRef: 'tok-1' }));
+
+    const { tokenAnalyses, tokenAnalysisLinks } = store.getState().analysis.analysis;
+    expect(tokenAnalyses).toHaveLength(0);
+    expect(tokenAnalysisLinks).toHaveLength(0);
+  });
+
+  it('no-ops when the token has no approved link', () => {
+    const ta: TokenAnalysis = {
+      id: 'ta-1',
+      surfaceText: 'word',
+      morphemes: [{ id: 'm-1', form: 'word', writingSystem: 'und' }],
+    };
+    const store = createAnalysisStore({
+      analysis: { analysis: makeAnalysis(ta), analysisLanguage: 'und' },
+    });
+
+    store.dispatch(deleteMorphemes({ tokenRef: 'tok-other' }));
+
+    expect(store.getState().analysis.analysis.tokenAnalyses[0].morphemes).toHaveLength(1);
+  });
+
+  it('no-ops when the approved analysis has no morphemes', () => {
+    const ta: TokenAnalysis = { id: 'ta-1', surfaceText: 'word', gloss: { und: 'hi' } };
+    const store = createAnalysisStore({
+      analysis: { analysis: makeAnalysis(ta), analysisLanguage: 'und' },
+    });
+
+    store.dispatch(deleteMorphemes({ tokenRef: 'tok-1' }));
+
+    const { tokenAnalyses, tokenAnalysisLinks } = store.getState().analysis.analysis;
+    expect(tokenAnalyses).toHaveLength(1);
+    expect(tokenAnalyses[0].gloss).toStrictEqual({ und: 'hi' });
+    expect(tokenAnalysisLinks).toHaveLength(1);
+  });
+
+  it('keeps the analysis and link when it carries a part of speech but no gloss', () => {
+    const ta: TokenAnalysis = {
+      id: 'ta-1',
+      surfaceText: 'word',
+      pos: 'N',
+      morphemes: [{ id: 'm-1', form: 'word', writingSystem: 'und' }],
+    };
+    const store = createAnalysisStore({
+      analysis: { analysis: makeAnalysis(ta), analysisLanguage: 'und' },
+    });
+
+    store.dispatch(deleteMorphemes({ tokenRef: 'tok-1' }));
+
+    const { tokenAnalyses, tokenAnalysisLinks } = store.getState().analysis.analysis;
+    expect(tokenAnalyses).toHaveLength(1);
+    expect(tokenAnalyses[0].morphemes).toBeUndefined();
+    expect(tokenAnalyses[0].pos).toBe('N');
+    expect(tokenAnalysisLinks).toHaveLength(1);
+  });
+
+  it('keeps the analysis and link when it carries features but no gloss', () => {
+    const ta: TokenAnalysis = {
+      id: 'ta-1',
+      surfaceText: 'word',
+      features: { Case: 'Nom' },
+      morphemes: [{ id: 'm-1', form: 'word', writingSystem: 'und' }],
+    };
+    const store = createAnalysisStore({
+      analysis: { analysis: makeAnalysis(ta), analysisLanguage: 'und' },
+    });
+
+    store.dispatch(deleteMorphemes({ tokenRef: 'tok-1' }));
+
+    const { tokenAnalyses, tokenAnalysisLinks } = store.getState().analysis.analysis;
+    expect(tokenAnalyses).toHaveLength(1);
+    expect(tokenAnalyses[0].morphemes).toBeUndefined();
+    expect(tokenAnalyses[0].features).toStrictEqual({ Case: 'Nom' });
+    expect(tokenAnalysisLinks).toHaveLength(1);
+  });
+
+  it('keeps the analysis and link when it carries a lexicon sense reference but no gloss', () => {
+    const ta: TokenAnalysis = {
+      id: 'ta-1',
+      surfaceText: 'word',
+      glossSenseRef: { senseId: 'sense-1' },
+      morphemes: [{ id: 'm-1', form: 'word', writingSystem: 'und' }],
+    };
+    const store = createAnalysisStore({
+      analysis: { analysis: makeAnalysis(ta), analysisLanguage: 'und' },
+    });
+
+    store.dispatch(deleteMorphemes({ tokenRef: 'tok-1' }));
+
+    const { tokenAnalyses, tokenAnalysisLinks } = store.getState().analysis.analysis;
+    expect(tokenAnalyses).toHaveLength(1);
+    expect(tokenAnalyses[0].morphemes).toBeUndefined();
+    expect(tokenAnalyses[0].glossSenseRef).toStrictEqual({ senseId: 'sense-1' });
+    expect(tokenAnalysisLinks).toHaveLength(1);
+  });
+
+  it('repairs an orphaned approved link by removing it', () => {
+    const orphanLink: TokenAnalysisLink = {
+      analysisId: 'missing-uuid',
+      status: 'approved',
+      token: { tokenRef: 'tok-1', surfaceText: 'word' },
+    };
+    const store = createAnalysisStore({
+      analysis: {
+        analysis: { ...emptyAnalysis(), tokenAnalysisLinks: [orphanLink] },
+        analysisLanguage: 'und',
+      },
+    });
+
+    store.dispatch(deleteMorphemes({ tokenRef: 'tok-1' }));
+
+    // Every token-analysis reducer repairs orphaned approved links the same way; an orphan found
+    // during deletion is removed rather than left to dangle.
+    expect(store.getState().analysis.analysis.tokenAnalysisLinks).toHaveLength(0);
+  });
+});
+
+describe('writeMorphemeGloss', () => {
+  it('writes a gloss onto the specified morpheme', () => {
+    const ta: TokenAnalysis = {
+      id: 'ta-1',
+      surfaceText: 'unbelievable',
+      morphemes: [
+        { id: 'm-1', form: 'un-', writingSystem: 'und' },
+        { id: 'm-2', form: 'believe', writingSystem: 'und' },
+      ],
+    };
+    const store = createAnalysisStore({
+      analysis: { analysis: makeAnalysis(ta), analysisLanguage: 'und' },
+    });
+
+    store.dispatch(writeMorphemeGloss({ tokenRef: 'tok-1', morphemeId: 'm-1', value: 'not' }));
+
+    const updated = store.getState().analysis.analysis.tokenAnalyses.find((a) => a.id === 'ta-1');
+    expect(updated?.morphemes?.[0].gloss).toStrictEqual({ und: 'not' });
+    expect(updated?.morphemes?.[1].gloss).toBeUndefined();
+  });
+
+  it('drops the gloss object when a blank value clears its only entry', () => {
+    const ta: TokenAnalysis = {
+      id: 'ta-1',
+      surfaceText: 'unbelievable',
+      morphemes: [{ id: 'm-1', form: 'un-', writingSystem: 'und', gloss: { und: 'not' } }],
+    };
+    const store = createAnalysisStore({
+      analysis: { analysis: makeAnalysis(ta), analysisLanguage: 'und' },
+    });
+
+    store.dispatch(writeMorphemeGloss({ tokenRef: 'tok-1', morphemeId: 'm-1', value: '  ' }));
+
+    const updated = store.getState().analysis.analysis.tokenAnalyses.find((a) => a.id === 'ta-1');
+    expect(updated?.morphemes?.[0].gloss).toBeUndefined();
+  });
+
+  it('removes only the active language entry from a multi-language gloss when cleared', () => {
+    const ta: TokenAnalysis = {
+      id: 'ta-1',
+      surfaceText: 'unbelievable',
+      morphemes: [
+        { id: 'm-1', form: 'un-', writingSystem: 'und', gloss: { und: 'not', fr: 'non' } },
+      ],
+    };
+    const store = createAnalysisStore({
+      analysis: { analysis: makeAnalysis(ta), analysisLanguage: 'und' },
+    });
+
+    store.dispatch(writeMorphemeGloss({ tokenRef: 'tok-1', morphemeId: 'm-1', value: '' }));
+
+    const updated = store.getState().analysis.analysis.tokenAnalyses.find((a) => a.id === 'ta-1');
+    expect(updated?.morphemes?.[0].gloss).toStrictEqual({ fr: 'non' });
+  });
+
+  it('no-ops when a blank value clears a morpheme that has no gloss', () => {
+    const ta: TokenAnalysis = {
+      id: 'ta-1',
+      surfaceText: 'unbelievable',
+      morphemes: [{ id: 'm-1', form: 'un-', writingSystem: 'und' }],
+    };
+    const store = createAnalysisStore({
+      analysis: { analysis: makeAnalysis(ta), analysisLanguage: 'und' },
+    });
+
+    store.dispatch(writeMorphemeGloss({ tokenRef: 'tok-1', morphemeId: 'm-1', value: '' }));
+
+    const updated = store.getState().analysis.analysis.tokenAnalyses.find((a) => a.id === 'ta-1');
+    expect(updated?.morphemes?.[0].gloss).toBeUndefined();
+  });
+
+  it('no-ops when the token has no approved link', () => {
+    const store = createAnalysisStore();
+    store.dispatch(writeMorphemeGloss({ tokenRef: 'tok-1', morphemeId: 'm-1', value: 'not' }));
+    expect(store.getState().analysis.analysis.tokenAnalyses).toHaveLength(0);
+  });
+
+  it('repairs an orphaned approved link by removing it', () => {
+    const orphanLink: TokenAnalysisLink = {
+      analysisId: 'missing-uuid',
+      status: 'approved',
+      token: { tokenRef: 'tok-1', surfaceText: 'word' },
+    };
+    const store = createAnalysisStore({
+      analysis: {
+        analysis: { ...emptyAnalysis(), tokenAnalysisLinks: [orphanLink] },
+        analysisLanguage: 'und',
+      },
+    });
+
+    store.dispatch(writeMorphemeGloss({ tokenRef: 'tok-1', morphemeId: 'm-1', value: 'not' }));
+
+    expect(store.getState().analysis.analysis.tokenAnalysisLinks).toHaveLength(0);
+  });
+
+  it('no-ops when the morpheme id is not found', () => {
+    const ta: TokenAnalysis = {
+      id: 'ta-1',
+      surfaceText: 'word',
+      morphemes: [{ id: 'm-1', form: 'word', writingSystem: 'und' }],
+    };
+    const store = createAnalysisStore({
+      analysis: { analysis: makeAnalysis(ta), analysisLanguage: 'und' },
+    });
+
+    store.dispatch(
+      writeMorphemeGloss({ tokenRef: 'tok-1', morphemeId: 'nonexistent', value: 'x' }),
+    );
+
+    expect(
+      store.getState().analysis.analysis.tokenAnalyses[0].morphemes?.[0].gloss,
+    ).toBeUndefined();
+  });
+});
+
+describe('selectApprovedMorphemes', () => {
+  it('returns morphemes from the approved analysis', () => {
+    const ta: TokenAnalysis = {
+      id: 'ta-1',
+      surfaceText: 'word',
+      morphemes: [
+        { id: 'm-1', form: 'wor', writingSystem: 'und' },
+        { id: 'm-2', form: '-d', writingSystem: 'und' },
+      ],
+    };
+    const store = createAnalysisStore({
+      analysis: { analysis: makeAnalysis(ta), analysisLanguage: 'und' },
+    });
+
+    const morphemes = selectApprovedMorphemes(store.getState().analysis, 'tok-1');
+    expect(morphemes).toHaveLength(2);
+    expect(morphemes[0].form).toBe('wor');
+  });
+
+  it('returns an empty array when no approved link exists', () => {
+    const store = createAnalysisStore();
+    const morphemes = selectApprovedMorphemes(store.getState().analysis, 'tok-1');
+    expect(morphemes).toHaveLength(0);
+  });
+
+  it('returns an empty array when approved analysis has no morphemes', () => {
+    const ta: TokenAnalysis = { id: 'ta-1', surfaceText: 'word' };
+    const store = createAnalysisStore({
+      analysis: { analysis: makeAnalysis(ta), analysisLanguage: 'und' },
+    });
+
+    const morphemes = selectApprovedMorphemes(store.getState().analysis, 'tok-1');
+    expect(morphemes).toHaveLength(0);
+  });
+
+  it('returns the same reference for repeated calls (stable empty array)', () => {
+    const store = createAnalysisStore();
+    const a = selectApprovedMorphemes(store.getState().analysis, 'tok-1');
+    const b = selectApprovedMorphemes(store.getState().analysis, 'tok-1');
+    expect(a).toBe(b);
+  });
+});
diff --git a/src/__tests__/test-helpers.ts b/src/__tests__/test-helpers.ts
index 7edb2222..befaecac 100644
--- a/src/__tests__/test-helpers.ts
+++ b/src/__tests__/test-helpers.ts
@@ -83,6 +83,7 @@ export function makePhraseStripContext(
     onHoverSplitFreeTokens: () => {},
     hideInactiveLinkButtons: false,
     simplifyPhrases: false,
+    showMorphology: false,
     activeSegmentId: undefined,
     crossSegmentLinkTooltip: '',
     skipLinkTransition: false,
diff --git a/src/components/AnalysisStore.tsx b/src/components/AnalysisStore.tsx
index 3a9de42a..5e32721e 100644
--- a/src/components/AnalysisStore.tsx
+++ b/src/components/AnalysisStore.tsx
@@ -1,19 +1,29 @@
 /** @file Analysis store backed by Redux Toolkit with per-token subscriptions via `useSelector`. */
-import type { PhraseAnalysisLink, TextAnalysis, TokenSnapshot } from 'interlinearizer';
+import type {
+  MorphemeAnalysis,
+  PhraseAnalysisLink,
+  TextAnalysis,
+  TokenSnapshot,
+} from 'interlinearizer';
 import { createContext, useCallback, useContext, useMemo, useRef } from 'react';
 import type { ReactNode } from 'react';
 import { Provider as ReduxProvider, useDispatch, useSelector, useStore } from 'react-redux';
 import {
   createPhrase,
+  deleteMorphemes,
   deletePhrase,
   mergePhrases,
   selectAnalysis,
+  selectAnalysisLanguage,
   selectApprovedGloss,
+  selectApprovedMorphemes,
   selectPhraseLinkByAnalysisId,
   selectPhraseLinkByTokenRef,
   selectPhraseGloss,
   updatePhrase,
   writeGloss,
+  writeMorphemeGloss,
+  writeMorphemes,
   writePhraseGloss,
 } from '../store/analysisSlice';
 import { createAnalysisStore, type AnalysisDispatch, type AnalysisRootState } from '../store';
@@ -108,6 +118,48 @@ export function AnalysisStoreProvider({
 
 // #endregion
 
+// #region Internal hooks
+
+/**
+ * Reads the nearest {@link AnalysisStoreProvider}'s callback refs, throwing a hook-named error when
+ * called outside a provider. Centralizes the guard every analysis hook shares.
+ *
+ * @param hookName - Name of the calling hook, used in the thrown error message.
+ * @returns The provider's {@link CallbackRefs}.
+ * @throws When called outside an {@link AnalysisStoreProvider}.
+ */
+function useRequiredCallbacks(hookName: string): CallbackRefs {
+  const ctx = useContext(AnalysisCallbackCtx);
+  if (!ctx) throw new Error(`${hookName} must be used inside an AnalysisStoreProvider`);
+  return ctx;
+}
+
+/**
+ * Shared setup for the mutation hooks: resolves the provider callbacks and Redux dispatch, and
+ * returns a stable `save` that reads the latest analysis from the store and forwards it to
+ * `onSave`. Factors out the dispatch-then-save pattern every write hook repeats.
+ *
+ * @param hookName - Name of the calling hook, used in the guard's error message.
+ * @returns The provider callbacks, the typed `dispatch`, and a stable `save` callback.
+ * @throws When called outside an {@link AnalysisStoreProvider}.
+ */
+function useAnalysisSave(hookName: string): {
+  callbacks: CallbackRefs;
+  dispatch: AnalysisDispatch;
+  save: () => void;
+} {
+  const callbacks = useRequiredCallbacks(hookName);
+  const dispatch = useDispatch<AnalysisDispatch>();
+  const store = useStore<AnalysisRootState>();
+  const save = useCallback(() => {
+    const { analysis } = store.getState().analysis;
+    callbacks.onSaveRef.current?.(analysis);
+  }, [store, callbacks]);
+  return { callbacks, dispatch, save };
+}
+
+// #endregion
+
 // #region Token hooks
 
 /**
@@ -119,12 +171,40 @@ export function AnalysisStoreProvider({
  * @throws When called outside an {@link AnalysisStoreProvider}.
  */
 export function useGloss(tokenRef: string): string {
-  const ctx = useContext(AnalysisCallbackCtx);
-  if (!ctx) throw new Error('useGloss must be used inside an AnalysisStoreProvider');
+  useRequiredCallbacks('useGloss');
 
   return useSelector((state: AnalysisRootState) => selectApprovedGloss(state.analysis, tokenRef));
 }
 
+/**
+ * Returns the morpheme breakdown from the approved `TokenAnalysis` for `tokenRef`, re-rendering
+ * only when the morpheme array changes. Returns a stable empty array when no approved analysis
+ * exists or it has no morphemes.
+ *
+ * @param tokenRef - The `Token.ref` to look up.
+ * @returns The morpheme array from the approved analysis, or a stable empty array.
+ * @throws When called outside an {@link AnalysisStoreProvider}.
+ */
+export function useMorphemes(tokenRef: string): readonly MorphemeAnalysis[] {
+  useRequiredCallbacks('useMorphemes');
+
+  return useSelector((state: AnalysisRootState) =>
+    selectApprovedMorphemes(state.analysis, tokenRef),
+  );
+}
+
+/**
+ * Returns the active BCP 47 analysis-language tag from the nearest {@link AnalysisStoreProvider}.
+ *
+ * @returns The analysis language string.
+ * @throws When called outside an {@link AnalysisStoreProvider}.
+ */
+export function useAnalysisLanguage(): string {
+  useRequiredCallbacks('useAnalysisLanguage');
+
+  return useSelector((state: AnalysisRootState) => selectAnalysisLanguage(state.analysis));
+}
+
 /**
  * Returns the current `TextAnalysis` snapshot, re-rendering on every analysis change. Intended for
  * components that need the full analysis (e.g. an analysis-selection popup).
@@ -133,8 +213,7 @@ export function useGloss(tokenRef: string): string {
  * @throws When called outside an {@link AnalysisStoreProvider}.
  */
 export function useAnalysis(): TextAnalysis {
-  const ctx = useContext(AnalysisCallbackCtx);
-  if (!ctx) throw new Error('useAnalysis must be used inside an AnalysisStoreProvider');
+  useRequiredCallbacks('useAnalysis');
 
   return useSelector((state: AnalysisRootState) => selectAnalysis(state.analysis));
 }
@@ -148,20 +227,85 @@ export function useAnalysis(): TextAnalysis {
  * @throws When called outside an {@link AnalysisStoreProvider}.
  */
 export function useGlossDispatch(): (tokenRef: string, surfaceText: string, value: string) => void {
-  const callbacks = useContext(AnalysisCallbackCtx);
-  if (!callbacks) throw new Error('useGlossDispatch must be used inside an AnalysisStoreProvider');
-
-  const dispatch = useDispatch<AnalysisDispatch>();
-  const store = useStore<AnalysisRootState>();
+  const { callbacks, dispatch, save } = useAnalysisSave('useGlossDispatch');
 
   return useCallback(
     (tokenRef: string, surfaceText: string, value: string) => {
       dispatch(writeGloss(tokenRef, surfaceText, value));
-      const { analysis } = store.getState().analysis;
-      callbacks.onSaveRef.current?.(analysis);
+      save();
       callbacks.onGlossChangeRef.current?.(tokenRef, value);
     },
-    [dispatch, store, callbacks],
+    [dispatch, save, callbacks],
+  );
+}
+
+/**
+ * Returns a stable callback that replaces the morpheme breakdown on the approved `TokenAnalysis`
+ * for a given token. Dispatches the `writeMorphemes` action and triggers `onSave`.
+ *
+ * @returns A function `(tokenRef, surfaceText, forms, writingSystem) => void`, where
+ *   `writingSystem` is the BCP 47 tag of the token's surface text (`Token.writingSystem`), stored
+ *   on each morpheme as the writing system of its form.
+ * @throws When called outside an {@link AnalysisStoreProvider}.
+ */
+export function useMorphemeBreakdownDispatch(): (
+  tokenRef: string,
+  surfaceText: string,
+  forms: string[],
+  writingSystem: string,
+) => void {
+  const { dispatch, save } = useAnalysisSave('useMorphemeBreakdownDispatch');
+
+  return useCallback(
+    (tokenRef: string, surfaceText: string, forms: string[], writingSystem: string) => {
+      dispatch(writeMorphemes(tokenRef, surfaceText, forms, writingSystem));
+      save();
+    },
+    [dispatch, save],
+  );
+}
+
+/**
+ * Returns a stable callback that removes the morpheme breakdown from the approved `TokenAnalysis`
+ * for a given token (deleting the analysis record entirely when it carries no gloss). Dispatches
+ * the `deleteMorphemes` action and triggers `onSave`.
+ *
+ * @returns A function `(tokenRef) => void`.
+ * @throws When called outside an {@link AnalysisStoreProvider}.
+ */
+export function useMorphemeDeleteDispatch(): (tokenRef: string) => void {
+  const { dispatch, save } = useAnalysisSave('useMorphemeDeleteDispatch');
+
+  return useCallback(
+    (tokenRef: string) => {
+      dispatch(deleteMorphemes({ tokenRef }));
+      save();
+    },
+    [dispatch, save],
+  );
+}
+
+/**
+ * Returns a stable callback that writes a gloss on a single morpheme within the approved
+ * `TokenAnalysis` for a given token. Dispatches the `writeMorphemeGloss` action and triggers
+ * `onSave`.
+ *
+ * @returns A function `(tokenRef, morphemeId, value) => void`.
+ * @throws When called outside an {@link AnalysisStoreProvider}.
+ */
+export function useMorphemeGlossDispatch(): (
+  tokenRef: string,
+  morphemeId: string,
+  value: string,
+) => void {
+  const { dispatch, save } = useAnalysisSave('useMorphemeGlossDispatch');
+
+  return useCallback(
+    (tokenRef: string, morphemeId: string, value: string) => {
+      dispatch(writeMorphemeGloss({ tokenRef, morphemeId, value }));
+      save();
+    },
+    [dispatch, save],
   );
 }
 
@@ -177,8 +321,7 @@ export function useGlossDispatch(): (tokenRef: string, surfaceText: string, valu
  * @throws When called outside an {@link AnalysisStoreProvider}.
  */
 export function usePhraseLinkMap(): Map<string, PhraseAnalysisLink> {
-  const ctx = useContext(AnalysisCallbackCtx);
-  if (!ctx) throw new Error('usePhraseLinkMap must be used inside an AnalysisStoreProvider');
+  useRequiredCallbacks('usePhraseLinkMap');
 
   return useSelector((state: AnalysisRootState) => selectPhraseLinkByTokenRef(state.analysis));
 }
@@ -191,8 +334,7 @@ export function usePhraseLinkMap(): Map<string, PhraseAnalysisLink> {
  * @throws When called outside an {@link AnalysisStoreProvider}.
  */
 export function usePhraseLinkByIdMap(): Map<string, PhraseAnalysisLink> {
-  const ctx = useContext(AnalysisCallbackCtx);
-  if (!ctx) throw new Error('usePhraseLinkByIdMap must be used inside an AnalysisStoreProvider');
+  useRequiredCallbacks('usePhraseLinkByIdMap');
 
   return useSelector((state: AnalysisRootState) => selectPhraseLinkByAnalysisId(state.analysis));
 }
@@ -207,8 +349,7 @@ export function usePhraseLinkByIdMap(): Map<string, PhraseAnalysisLink> {
  * @throws When called outside an {@link AnalysisStoreProvider}.
  */
 export function usePhraseLinkForToken(tokenRef: string): PhraseAnalysisLink | undefined {
-  const ctx = useContext(AnalysisCallbackCtx);
-  if (!ctx) throw new Error('usePhraseLinkForToken must be used inside an AnalysisStoreProvider');
+  useRequiredCallbacks('usePhraseLinkForToken');
 
   return useSelector((state: AnalysisRootState) =>
     selectPhraseLinkByTokenRef(state.analysis).get(tokenRef),
@@ -224,8 +365,7 @@ export function usePhraseLinkForToken(tokenRef: string): PhraseAnalysisLink | un
  * @throws When called outside an {@link AnalysisStoreProvider}.
  */
 export function usePhraseGloss(phraseId: string): string {
-  const ctx = useContext(AnalysisCallbackCtx);
-  if (!ctx) throw new Error('usePhraseGloss must be used inside an AnalysisStoreProvider');
+  useRequiredCallbacks('usePhraseGloss');
 
   return useSelector((state: AnalysisRootState) => selectPhraseGloss(state.analysis, phraseId));
 }
@@ -237,20 +377,14 @@ export function usePhraseGloss(phraseId: string): string {
  * @throws When called outside an {@link AnalysisStoreProvider}.
  */
 export function usePhraseGlossDispatch(): (phraseId: string, value: string) => void {
-  const callbacks = useContext(AnalysisCallbackCtx);
-  if (!callbacks)
-    throw new Error('usePhraseGlossDispatch must be used inside an AnalysisStoreProvider');
-
-  const dispatch = useDispatch<AnalysisDispatch>();
-  const store = useStore<AnalysisRootState>();
+  const { dispatch, save } = useAnalysisSave('usePhraseGlossDispatch');
 
   return useCallback(
     (phraseId: string, value: string) => {
       dispatch(writePhraseGloss({ phraseId, value }));
-      const { analysis } = store.getState().analysis;
-      callbacks.onSaveRef.current?.(analysis);
+      save();
     },
-    [dispatch, store, callbacks],
+    [dispatch, save],
   );
 }
 
@@ -303,16 +437,7 @@ export type PhraseDispatch = {
  * @throws When called outside an {@link AnalysisStoreProvider}.
  */
 export function usePhraseDispatch(): PhraseDispatch {
-  const callbacks = useContext(AnalysisCallbackCtx);
-  if (!callbacks) throw new Error('usePhraseDispatch must be used inside an AnalysisStoreProvider');
-
-  const dispatch = useDispatch<AnalysisDispatch>();
-  const store = useStore<AnalysisRootState>();
-
-  const save = useCallback(() => {
-    const { analysis } = store.getState().analysis;
-    callbacks.onSaveRef.current?.(analysis);
-  }, [store, callbacks]);
+  const { dispatch, save } = useAnalysisSave('usePhraseDispatch');
 
   const handleCreatePhrase = useCallback(
     (tokens: TokenSnapshot[]): string => {
diff --git a/src/components/ContinuousView.tsx b/src/components/ContinuousView.tsx
index 3102e704..2374d42b 100644
--- a/src/components/ContinuousView.tsx
+++ b/src/components/ContinuousView.tsx
@@ -4,6 +4,7 @@ import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } fr
 import type { Dispatch, SetStateAction } from 'react';
 import { usePhraseLinkByIdMap, usePhraseLinkMap } from './AnalysisStore';
 import type { PhraseMode } from '../types/phrase-mode';
+import type { ViewOptions } from '../types/view-options';
 import { PhraseStripProvider } from './PhraseStripContext';
 import { PhraseStrip, LINK_SLOT_TRANSITION_MS, type StripItem } from './PhraseStripParts';
 import type { LinkSlot, TokenGroup } from '../types/token-layout';
@@ -108,15 +109,10 @@ type ContinuousViewProps = Readonly<{
   /** Word token ref → token lookup; used to resolve the focused token from `focusedTokenRef`. */
   wordTokenByRef: ReadonlyMap<string, Token & { type: 'word' }>;
   /**
-   * When `true`, link/unlink buttons between phrases are hidden except in the segment containing
-   * the focused token (the active verse within the strip).
+   * Bundled display toggles. The strip reads `hideInactiveLinkButtons`, `simplifyPhrases`, and
+   * `showMorphology`; `chapterLabelInVerse` does not apply to the continuous strip.
    */
-  hideInactiveLinkButtons: boolean;
-  /**
-   * When `true`, phrase-level controls (split, intra-phrase unlink, remove-token) are hidden on
-   * every phrase except the focused one.
-   */
-  simplifyPhrases: boolean;
+  viewOptions: ViewOptions;
 }>;
 
 /**
@@ -142,10 +138,8 @@ type ContinuousViewProps = Readonly<{
  * @param props.tokenDocOrder - Word token ref → flat book-level index for document-order phrase
  *   merges
  * @param props.wordTokenByRef - Word token ref → token lookup for focus resolution
- * @param props.hideInactiveLinkButtons - When true, link buttons between phrases are hidden outside
- *   the focused token's segment.
- * @param props.simplifyPhrases - When true, phrase-level controls are hidden on every phrase except
- *   the focused one.
+ * @param props.viewOptions - Bundled display toggles; the strip reads all but
+ *   `chapterLabelInVerse`.
  * @returns A horizontal phrase strip with previous/next navigation arrows and edge-fade overlays
  */
 export default function ContinuousView({
@@ -158,9 +152,9 @@ export default function ContinuousView({
   tokenSegmentMap,
   tokenDocOrder,
   wordTokenByRef,
-  hideInactiveLinkButtons,
-  simplifyPhrases,
+  viewOptions,
 }: ContinuousViewProps) {
+  const { hideInactiveLinkButtons, simplifyPhrases, showMorphology } = viewOptions;
   const isRtl = document.documentElement.dir === 'rtl';
 
   const [localizedStrings] = useLocalizedStrings(STRING_KEYS);
@@ -578,17 +572,18 @@ export default function ContinuousView({
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [committedActiveSegmentId]);
 
-  // Re-center the focused group when a view option toggles. Toggling `simplifyPhrases` changes
-  // the strip's layout, so the previously-centered group may drift off-center; snap it back into
-  // view. `hideInactiveLinkButtons` is excluded: inactive link slots now reserve their space even
-  // when hidden (`opacity: 0`; clickability is guarded at the button level), so toggling it does
-  // not shift the layout.
+  // Re-center the focused group when a view option toggles. Toggling `simplifyPhrases` or
+  // `showMorphology` changes the strip's layout (morpheme rows can widen phrase boxes), so the
+  // previously-centered group may drift off-center; snap it back into view.
+  // `hideInactiveLinkButtons` is excluded: inactive link slots now reserve their space even when
+  // hidden (`opacity: 0`; clickability is guarded at the button level), so toggling it does not
+  // shift the layout.
   useEffect(() => {
     centerGroup(focusPhraseIndex, 'auto');
     // focusPhraseIndex is intentionally excluded: it has its own scroll effect above. This effect
     // only re-centers in response to layout-affecting option toggles. centerGroup is stable.
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [simplifyPhrases]);
+  }, [simplifyPhrases, showMorphology]);
 
   // When entering edit or confirm-unlink mode, smooth-scroll to the first group of the active
   // phrase by notifying the parent of the new focused token. Scroll then follows automatically
@@ -663,6 +658,7 @@ export default function ContinuousView({
     crossSegmentLinkTooltip:
       localizedStrings['%interlinearizer_linkButton_crossSegmentDisabledTooltip%'],
     skipLinkTransition: !isVisible || skipSlotTransitionForJump,
+    showMorphology,
   });
 
   /**
diff --git a/src/components/Interlinearizer.tsx b/src/components/Interlinearizer.tsx
index db026049..1df92d49 100644
--- a/src/components/Interlinearizer.tsx
+++ b/src/components/Interlinearizer.tsx
@@ -8,6 +8,7 @@ import EditPhraseControls from './controls/EditPhraseControls';
 import useBookIndexes from '../hooks/useBookIndexes';
 import useLatestRef from '../hooks/useLatestRef';
 import type { PhraseMode } from '../types/phrase-mode';
+import type { ViewOptions } from '../types/view-options';
 import { isWordToken } from '../types/type-guards';
 import { isSameVerse, toSerializedVerseRef } from '../utils/verse-ref';
 import SegmentListView from './SegmentListView';
@@ -53,16 +54,8 @@ type InterlinearizerProps = Readonly<{
   phraseMode: PhraseMode;
   /** Setter for `phraseMode`; passed down so child components can transition modes. */
   setPhraseMode: Dispatch<SetStateAction<PhraseMode>>;
-  /** When true, link buttons between phrases are hidden in segments other than the active verse. */
-  hideInactiveLinkButtons: boolean;
-  /** When true, phrase-level controls are hidden on every phrase except the focused one. */
-  simplifyPhrases: boolean;
-  /**
-   * When true, every verse is labeled `chapter:verse` and no inline chapter header is shown; when
-   * false, an inline chapter header precedes the first verse of each chapter and verse labels stay
-   * bare verse numbers.
-   */
-  chapterLabelInVerse: boolean;
+  /** Bundled display toggles forwarded to the segment list and continuous views. */
+  viewOptions: ViewOptions;
 }>;
 
 /**
@@ -77,12 +70,8 @@ type InterlinearizerProps = Readonly<{
  * @param props.phraseMode - Current phrase-interaction mode passed down for rendering.
  * @param props.setPhraseMode - Setter for `phraseMode`; passed to child components so they can
  *   transition modes.
- * @param props.hideInactiveLinkButtons - When true, link buttons between phrases are hidden in
- *   segments other than the active verse.
- * @param props.simplifyPhrases - When true, phrase-level controls are hidden on every phrase except
- *   the focused one.
- * @param props.chapterLabelInVerse - When true, every verse is labeled `chapter:verse` instead of
- *   showing an inline chapter header.
+ * @param props.viewOptions - Bundled display toggles forwarded to the segment list and continuous
+ *   views.
  * @returns The interlinearizer layout without the provider wrapper.
  */
 function InterlinearizerInner({
@@ -91,9 +80,7 @@ function InterlinearizerInner({
   scrRef,
   phraseMode,
   setPhraseMode,
-  hideInactiveLinkButtons,
-  simplifyPhrases,
-  chapterLabelInVerse,
+  viewOptions,
 }: Omit<InterlinearizerProps, 'initialAnalysis' | 'analysisLanguage' | 'onSaveAnalysis'>) {
   // Navigation surface from the context: `navigate` writes the reference (classifying internal vs
   // external at the call site), `consumeInternalNav` lets the segment window suppress the fade for
@@ -282,8 +269,7 @@ function InterlinearizerInner({
               tokenSegmentMap={tokenSegmentMap}
               tokenDocOrder={tokenDocOrder}
               wordTokenByRef={wordTokenByRef}
-              hideInactiveLinkButtons={hideInactiveLinkButtons}
-              simplifyPhrases={simplifyPhrases}
+              viewOptions={viewOptions}
             />
           </div>
         )}
@@ -299,9 +285,7 @@ function InterlinearizerInner({
           reportSettled={reportSettled}
           phraseMode={phraseMode}
           setPhraseMode={setPhraseMode}
-          hideInactiveLinkButtons={hideInactiveLinkButtons}
-          simplifyPhrases={simplifyPhrases}
-          chapterLabelInVerse={chapterLabelInVerse}
+          viewOptions={viewOptions}
           hoveredPhraseId={hoveredPhraseId}
           setHoveredPhraseId={setHoveredPhraseId}
           editPhraseSegmentId={editPhraseSegmentId}
@@ -330,10 +314,8 @@ function InterlinearizerInner({
  * @param props.onSaveAnalysis - Called after each gloss write with the updated `TextAnalysis`
  * @param props.phraseMode - Current phrase-interaction mode owned by the parent
  * @param props.setPhraseMode - Setter for `phraseMode`
- * @param props.hideInactiveLinkButtons - When true, link buttons between phrases are hidden in
- *   segments other than the active verse.
- * @param props.simplifyPhrases - When true, phrase-level controls are hidden on every phrase except
- *   the focused one.
+ * @param props.viewOptions - Bundled display toggles forwarded to the segment list and continuous
+ *   views.
  * @returns The full interlinearizer layout with optional continuous strip and segment list
  */
 export default function Interlinearizer({
diff --git a/src/components/InterlinearizerLoader.tsx b/src/components/InterlinearizerLoader.tsx
index 470064a9..395ac8fa 100644
--- a/src/components/InterlinearizerLoader.tsx
+++ b/src/components/InterlinearizerLoader.tsx
@@ -220,6 +220,21 @@ function InterlinearizerLoaderInner({
     value: chapterLabelInVerse,
   } = useOptimisticBooleanSetting(projectId, 'interlinearizer.chapterLabelInVerse', false);
 
+  const {
+    isLoading: isShowMorphologyLoading,
+    onChange: handleShowMorphologyChange,
+    value: showMorphology,
+  } = useOptimisticBooleanSetting(projectId, 'interlinearizer.showMorphology', false);
+
+  // Bundle the display toggles into one stable object. Memoizing on the primitive values keeps
+  // the reference identical across the loader's frequent re-renders (driven by `useData`,
+  // `useSetting`, etc.), so the `memo()` wrapping `SegmentView` can shallow-compare it away instead
+  // of re-rendering every windowed segment when no toggle actually changed.
+  const viewOptions = useMemo(
+    () => ({ hideInactiveLinkButtons, simplifyPhrases, chapterLabelInVerse, showMorphology }),
+    [hideInactiveLinkButtons, simplifyPhrases, chapterLabelInVerse, showMorphology],
+  );
+
   const { book, isLoading, bookError, tokenizeError } = useInterlinearizerBookData({
     projectId,
     scrRef,
@@ -230,7 +245,8 @@ function InterlinearizerLoaderInner({
     isContinuousScrollLoading ||
     isHideInactiveLinkButtonsLoading ||
     isSimplifyPhrasesLoading ||
-    isChapterLabelInVerseLoading;
+    isChapterLabelInVerseLoading ||
+    isShowMorphologyLoading;
   // True during a cross-book swap: the live `scrRef` already names the new book but the loaded `book`
   // is still the previous one (its USJ hasn't arrived yet). The old `Interlinearizer` is still
   // mounted here; showing it (even frozen on its last in-book reference) lets the previous book's
@@ -337,6 +353,8 @@ function InterlinearizerLoaderInner({
               onSimplifyPhrasesChange={handleSimplifyPhrasesChange}
               chapterLabelInVerse={chapterLabelInVerse}
               onChapterLabelInVerseChange={handleChapterLabelInVerseChange}
+              showMorphology={showMorphology}
+              onShowMorphologyChange={handleShowMorphologyChange}
             />
           ) : undefined
         }
@@ -394,9 +412,7 @@ function InterlinearizerLoaderInner({
             onSaveAnalysis={handleSaveAnalysis}
             phraseMode={phraseMode}
             setPhraseMode={setPhraseMode}
-            hideInactiveLinkButtons={hideInactiveLinkButtons}
-            simplifyPhrases={simplifyPhrases}
-            chapterLabelInVerse={chapterLabelInVerse}
+            viewOptions={viewOptions}
           />
         )}
       </div>
diff --git a/src/components/MorphemeEditor.tsx b/src/components/MorphemeEditor.tsx
new file mode 100644
index 00000000..82c6bf4f
--- /dev/null
+++ b/src/components/MorphemeEditor.tsx
@@ -0,0 +1,286 @@
+/**
+ * @file Inline morpheme editing components rendered inside {@link TokenChip} when the morphology
+ *   toggle is active. {@link MorphemeBreakdownPopover} lets the user define or re-split a token's
+ *   morpheme forms; {@link MorphemeGlossInput} provides a per-morpheme gloss field.
+ */
+import type { MorphemeAnalysis } from 'interlinearizer';
+import { useLocalizedStrings } from '@papi/frontend/react';
+import { PopoverContent } from 'platform-bible-react';
+import { useEffect, useId, useRef, useState } from 'react';
+import type { KeyboardEvent, MouseEvent } from 'react';
+import { useMorphemeGlossDispatch } from './AnalysisStore';
+
+const POPOVER_STRING_KEYS = [
+  '%interlinearizer_morphemeEditor_splitLabel%',
+  '%interlinearizer_morphemeEditor_delete%',
+  '%interlinearizer_morphemeEditor_cancel%',
+  '%interlinearizer_morphemeEditor_done%',
+] as const satisfies `%${string}%`[];
+
+const MORPHEME_GLOSS_STRING_KEYS = [
+  '%interlinearizer_morphemeGloss_label%',
+] as const satisfies `%${string}%`[];
+
+/**
+ * Inline popover for defining or editing a token's morpheme breakdown. The user types
+ * space-separated morpheme forms (e.g. "un- believe -able") and commits with Enter, Done, or by
+ * clicking outside the popover (matching the commit-on-blur behavior of gloss inputs). Cancel and
+ * Escape dismiss without saving. An unedited draft is never re-saved over an existing breakdown —
+ * Enter, Done, and outside clicks all dismiss instead, because re-saving identical forms would only
+ * rewrite identical data. A breakdown that is empty or just the whole word as a single morpheme
+ * carries no real segmentation, so it is never saved either: the Done button is disabled for it and
+ * the Enter / outside-click paths dismiss without writing.
+ *
+ * Renders the content of a `platform-bible-react` `Popover`; the caller owns the `Popover` root and
+ * the `PopoverAnchor` the panel is positioned from, and must render this component only while the
+ * popover is open so the draft state re-initializes from `initialValue` on every open. The popover
+ * is modal, so interactions outside the panel are blocked while it is open.
+ *
+ * @param props - Component props.
+ * @param props.initialValue - Pre-filled text for the input (current morpheme forms joined by
+ *   spaces, or the full surface text when no breakdown exists yet).
+ * @param props.onSave - Called with the raw input string when the user commits.
+ * @param props.onClose - Called to dismiss the popover.
+ * @param props.onDelete - When provided, a Delete button is shown that calls this to remove the
+ *   token's existing morpheme breakdown, then dismisses the popover. Callers should omit it when
+ *   the token has no breakdown to delete; its presence is also how the popover knows a breakdown
+ *   already exists when deciding whether an unedited commit should save.
+ * @param props.surfaceText - The token's surface text, used to reject a "breakdown" that is just
+ *   the whole word as a single morpheme (no real segmentation).
+ * @param props.glossInputId - Id of the token's gloss input; used to locate the chip on close so
+ *   focus lands on its first morpheme gloss field (falling back to the gloss input itself), rather
+ *   than on the non-tabbable morpheme trigger.
+ * @returns A popover panel with a text input and Cancel/Done buttons.
+ */
+export function MorphemeBreakdownPopover({
+  initialValue,
+  onSave,
+  onClose,
+  onDelete,
+  surfaceText,
+  glossInputId,
+}: Readonly<{
+  initialValue: string;
+  onSave: (value: string) => void;
+  onClose: () => void;
+  onDelete?: () => void;
+  surfaceText: string;
+  glossInputId: string;
+}>) {
+  const [localizedStrings] = useLocalizedStrings(POPOVER_STRING_KEYS);
+  const inputId = useId();
+  const [draft, setDraft] = useState(initialValue);
+  // eslint-disable-next-line no-null/no-null
+  const inputRef = useRef<HTMLInputElement | null>(null);
+
+  // Focus and select the input on open. The popover's own auto-focus is suppressed (see
+  // onOpenAutoFocus below) so this effect, which runs after it, is the only focus on open.
+  useEffect(() => {
+    inputRef.current?.focus();
+    inputRef.current?.select();
+  }, []);
+
+  /**
+   * Collapses leading/trailing and repeated internal whitespace to a single space.
+   *
+   * @param s - The string to normalize.
+   * @returns The string with surrounding whitespace trimmed and internal runs collapsed.
+   */
+  const normalize = (s: string) => s.trim().replace(/\s+/g, ' ');
+
+  // Whether the draft matches the pre-filled value. Shared by the Done/Enter and outside-click
+  // commit paths so the two can never disagree about what counts as an edit. Whitespace is
+  // normalized because the save path splits on /\s+/, so differing spacing yields identical forms —
+  // comparing normalized text avoids a no-op persistence round-trip.
+  const isUnedited = normalize(draft) === normalize(initialValue);
+
+  // A breakdown carries no real segmentation when it is empty or is just the whole word as a single
+  // morpheme equal to the surface text; in both cases there is nothing worth persisting.
+  const normalized = normalize(draft);
+  const forms = normalized === '' ? [] : normalized.split(' ');
+  const isMeaningless =
+    forms.length === 0 || (forms.length === 1 && forms[0] === normalize(surfaceText));
+
+  /**
+   * Commits the current draft and closes the popover. Skips the save when the breakdown is
+   * meaningless (empty, or the whole word as one morpheme), or when the token already has a
+   * breakdown (`onDelete` provided) and the text was not edited — re-saving identical forms would
+   * only rewrite identical data.
+   */
+  const handleSave = () => {
+    if (isMeaningless || (onDelete && isUnedited)) {
+      onClose();
+      return;
+    }
+    onSave(draft.trim());
+    onClose();
+  };
+
+  /**
+   * Handles Enter to commit. Escape is handled by the popover itself (`onEscapeKeyDown`).
+   *
+   * @param e - The keyboard event.
+   */
+  const handleKeyDown = (e: KeyboardEvent<HTMLInputElement>) => {
+    if (e.key === 'Enter') {
+      e.preventDefault();
+      handleSave();
+    }
+  };
+
+  /**
+   * Commits the draft when the user interacts outside the popover, except when the text was not
+   * edited — then the interaction acts like Cancel, because an accidental outside click is not a
+   * deliberate commit. An edited-but-meaningless draft is also dismissed without saving by
+   * {@link handleSave}.
+   */
+  const handleInteractOutside = () => {
+    if (isUnedited) {
+      onClose();
+      return;
+    }
+    handleSave();
+  };
+
+  /**
+   * Stops mouse events inside the panel from reaching ancestor handlers. The panel is portaled to
+   * document.body, but React synthetic events still bubble through the React tree (portal boundary
+   * included) to the token chip's label mouse-down handler and its phrase-selection click handlers
+   * — which would steal focus to the gloss input behind the popover. The events' default actions
+   * are left alone so interactions inside the panel (e.g. the panel's own label focusing its input)
+   * keep their native behavior.
+   *
+   * @param e - The mouse event on the popover panel.
+   */
+  const stopMouseEvents = (e: MouseEvent) => {
+    e.stopPropagation();
+  };
+
+  /**
+   * Overrides Radix's default close-focus behavior to land focus on the chip's first morpheme gloss
+   * field. The morpheme gloss inputs sit before the token gloss input inside the same label, so the
+   * lookup is scoped to that label — the panel is portaled to `document.body`, so a document-wide
+   * query could match another token's field. Falls back to the token gloss input when no morpheme
+   * field exists (dismissed with no breakdown, or deleted).
+   *
+   * @param e - The Radix close auto-focus event.
+   */
+  const handleCloseAutoFocus = (e: Event) => {
+    e.preventDefault();
+    const glossInput = document.getElementById(glossInputId);
+    const firstMorphemeGloss = glossInput
+      ?.closest('label')
+      ?.querySelector<HTMLInputElement>('input[data-morpheme-gloss]');
+    // `preventScroll` keeps the React-controlled scroll the sole scroller.
+    (firstMorphemeGloss ?? glossInput)?.focus({ preventScroll: true });
+  };
+
+  return (
+    <PopoverContent
+      align="start"
+      className="tw:flex tw:w-auto tw:min-w-48 tw:flex-col tw:gap-1.5 tw:p-2"
+      onClick={stopMouseEvents}
+      onCloseAutoFocus={handleCloseAutoFocus}
+      onEscapeKeyDown={onClose}
+      onInteractOutside={handleInteractOutside}
+      onMouseDown={stopMouseEvents}
+      onOpenAutoFocus={(e) => e.preventDefault()}
+    >
+      <label className="tw:text-xs tw:text-muted-foreground" htmlFor={inputId}>
+        {localizedStrings['%interlinearizer_morphemeEditor_splitLabel%']}
+      </label>
+      <input
+        ref={inputRef}
+        className="tw:w-full tw:rounded tw:border tw:border-input tw:bg-background tw:px-2 tw:py-1 tw:text-sm tw:font-mono"
+        id={inputId}
+        value={draft}
+        onChange={(e) => setDraft(e.target.value)}
+        onKeyDown={handleKeyDown}
+        type="text"
+      />
+      <div className="tw:flex tw:justify-end tw:gap-1.5">
+        {onDelete && (
+          <button
+            className="tw:me-auto tw:rounded tw:border tw:border-destructive tw:px-3 tw:py-0.5 tw:text-xs tw:text-destructive tw:hover:bg-destructive/10"
+            type="button"
+            onClick={() => {
+              onDelete();
+              onClose();
+            }}
+          >
+            {localizedStrings['%interlinearizer_morphemeEditor_delete%']}
+          </button>
+        )}
+        <button
+          className="tw:rounded tw:border tw:border-border tw:px-3 tw:py-0.5 tw:text-xs tw:text-muted-foreground tw:hover:bg-accent"
+          type="button"
+          onClick={onClose}
+        >
+          {localizedStrings['%interlinearizer_morphemeEditor_cancel%']}
+        </button>
+        <button
+          className="tw:rounded tw:bg-primary tw:px-3 tw:py-0.5 tw:text-xs tw:text-primary-foreground tw:hover:bg-primary/90 tw:disabled:opacity-50 tw:disabled:pointer-events-none"
+          disabled={isMeaningless}
+          type="button"
+          onClick={handleSave}
+        >
+          {localizedStrings['%interlinearizer_morphemeEditor_done%']}
+        </button>
+      </div>
+    </PopoverContent>
+  );
+}
+
+/**
+ * Renders a single morpheme's gloss as an inline editable input. Writes to the store on blur when
+ * the draft differs from the committed value. The input carries a `data-morpheme-gloss` attribute
+ * so container-level "focus the first gloss input" handlers (e.g. {@link PhraseBox}) can exclude
+ * morpheme glosses, which precede the token gloss input in DOM order.
+ *
+ * @param props - Component props.
+ * @param props.morpheme - The morpheme whose gloss is being edited.
+ * @param props.tokenRef - The token ref for dispatching gloss writes.
+ * @param props.analysisLanguage - BCP 47 tag for reading/writing the gloss.
+ * @param props.disabled - When true, the input is read-only.
+ * @returns A sized text input for the morpheme gloss.
+ */
+export function MorphemeGlossInput({
+  morpheme,
+  tokenRef,
+  analysisLanguage,
+  disabled,
+}: Readonly<{
+  morpheme: MorphemeAnalysis;
+  tokenRef: string;
+  analysisLanguage: string;
+  disabled: boolean;
+}>) {
+  const committed = morpheme.gloss?.[analysisLanguage] ?? '';
+  const dispatchMorphemeGloss = useMorphemeGlossDispatch();
+  const [draft, setDraft] = useState(committed);
+  const [localizedStrings] = useLocalizedStrings(MORPHEME_GLOSS_STRING_KEYS);
+
+  useEffect(() => {
+    setDraft(committed);
+  }, [committed]);
+
+  return (
+    <input
+      aria-label={localizedStrings['%interlinearizer_morphemeGloss_label%'].replace(
+        '{form}',
+        () => morpheme.form,
+      )}
+      className="tw:gloss-input tw:text-xs"
+      data-morpheme-gloss="true"
+      disabled={disabled}
+      placeholder="—"
+      style={{ fieldSizing: 'content', minWidth: '2ch' }}
+      value={draft}
+      onChange={(e) => setDraft(e.target.value)}
+      onBlur={() => {
+        if (!disabled && draft !== committed) dispatchMorphemeGloss(tokenRef, morpheme.id, draft);
+      }}
+      type="text"
+    />
+  );
+}
diff --git a/src/components/PhraseBox.tsx b/src/components/PhraseBox.tsx
index 74e866bd..4081a2d5 100644
--- a/src/components/PhraseBox.tsx
+++ b/src/components/PhraseBox.tsx
@@ -162,6 +162,7 @@ export function PhraseBox({
     tokenSegmentMap,
     tokenDocOrder,
     simplifyPhrases,
+    showMorphology,
   } = usePhraseStripContext();
   // When simplifyPhrases is on, a phrase exposes its interactive controls only while focused.
   // Intra-phrase unlink icons are hidden via opacity/pointer-events (not unmounted) so the layout
@@ -189,13 +190,17 @@ export function PhraseBox({
    * background handler, which focused the segment's first phrase instead. Focus is forwarded with
    * `preventScroll` — the user clicked something already on screen, so the browser's default
    * scroll-focused-element-into-view would realign the segment list for no reason (the input may
-   * sit on another wrapped row of the phrase, partially out of view).
+   * sit on another wrapped row of the phrase, partially out of view). Morpheme gloss inputs are
+   * excluded from the lookup — when morphology is shown they precede the token gloss input in DOM
+   * order, and only the token gloss input fires the `onFocus` → {@link onFocusPhrase} chain.
    *
    * @param e - The container's click event.
    */
   const focusFirstGlossOnSelfClick = useCallback((e: ReactMouseEvent<HTMLDivElement>) => {
     if (e.target instanceof Element && e.target.closest('input, button, a, label')) return;
-    e.currentTarget.querySelector('input')?.focus({ preventScroll: true });
+    e.currentTarget
+      .querySelector<HTMLInputElement>('input:not([data-morpheme-gloss])')
+      ?.focus({ preventScroll: true });
   }, []);
 
   /**
@@ -209,7 +214,7 @@ export function PhraseBox({
     if (e.target !== e.currentTarget) return;
     if (e.key !== 'Enter' && e.key !== ' ') return;
     e.preventDefault();
-    e.currentTarget.querySelector('input')?.focus();
+    e.currentTarget.querySelector<HTMLInputElement>('input:not([data-morpheme-gloss])')?.focus();
   }, []);
 
   const handleEditClick = useCallback(() => {
@@ -394,6 +399,7 @@ export function PhraseBox({
                       ? () => handleViewPopOut(token.ref)
                       : undefined
                   }
+                  showMorphology={showMorphology}
                   token={token}
                 />
               </span>
@@ -432,7 +438,12 @@ export function PhraseBox({
                     ))}
                   </span>
                 )}
-                <MemoizedTokenChip disabled onFocus={handleFocus} token={token} />
+                <MemoizedTokenChip
+                  disabled
+                  onFocus={handleFocus}
+                  showMorphology={showMorphology}
+                  token={token}
+                />
               </span>
             ))}
           </span>
@@ -488,7 +499,12 @@ export function PhraseBox({
                 onClick={() => handleEditRemove(token.ref)}
                 onKeyDown={handlePerTokenKeyDown(token.ref)}
               >
-                <MemoizedTokenChip disabled onFocus={handleFocus} token={token} />
+                <MemoizedTokenChip
+                  disabled
+                  onFocus={handleFocus}
+                  showMorphology={showMorphology}
+                  token={token}
+                />
               </span>
             </span>
           ))}
@@ -530,7 +546,12 @@ export function PhraseBox({
           <span key={token.ref} className="tw:phrase-token-row">
             {i > 0 &&
               punctuationBetween?.[i - 1]?.map((p) => <InertTokenChip key={p.ref} token={p} />)}
-            <MemoizedTokenChip disabled onFocus={handleFocus} token={token} />
+            <MemoizedTokenChip
+              disabled
+              onFocus={handleFocus}
+              showMorphology={showMorphology}
+              token={token}
+            />
           </span>
         ))}
       </span>
diff --git a/src/components/PhraseStripContext.tsx b/src/components/PhraseStripContext.tsx
index d9bc5ad3..e0a7fb05 100644
--- a/src/components/PhraseStripContext.tsx
+++ b/src/components/PhraseStripContext.tsx
@@ -73,6 +73,11 @@ export type PhraseStripContextValue = Readonly<{
    * before the strip fades in, rather than animating while the strip is becoming visible.
    */
   skipLinkTransition: boolean;
+  /**
+   * When `true`, each word token displays its morpheme breakdown and per-morpheme glosses beneath
+   * the token-level gloss input.
+   */
+  showMorphology: boolean;
 }>;
 
 /** The phrase-strip context. `undefined` outside a provider so consumers can fail loudly. */
diff --git a/src/components/SegmentListView.tsx b/src/components/SegmentListView.tsx
index c715cd32..d6e73aed 100644
--- a/src/components/SegmentListView.tsx
+++ b/src/components/SegmentListView.tsx
@@ -4,6 +4,7 @@ import { LocateFixed } from 'lucide-react';
 import { Fragment, useCallback, useEffect, useMemo, useRef } from 'react';
 import type { Dispatch, SetStateAction } from 'react';
 import type { PhraseMode } from '../types/phrase-mode';
+import type { ViewOptions } from '../types/view-options';
 import MemoizedSegmentView from './SegmentView';
 import useSegmentWindow from '../hooks/useSegmentWindow';
 import { isSameVerse } from '../utils/verse-ref';
@@ -43,16 +44,8 @@ type SegmentListViewProps = Readonly<{
   phraseMode: PhraseMode;
   /** Setter for `phraseMode`; passed down so child components can transition modes. */
   setPhraseMode: Dispatch<SetStateAction<PhraseMode>>;
-  /** When true, link buttons between phrases are hidden in segments other than the active verse. */
-  hideInactiveLinkButtons: boolean;
-  /** When true, phrase-level controls are hidden on every phrase except the focused one. */
-  simplifyPhrases: boolean;
-  /**
-   * When true, every verse is labeled `chapter:verse` and no inline chapter header is shown; when
-   * false, verse labels stay bare verse numbers and an inline chapter header precedes the first
-   * verse of each chapter.
-   */
-  chapterLabelInVerse: boolean;
+  /** Bundled display toggles forwarded unchanged to each {@link SegmentView}. */
+  viewOptions: ViewOptions;
   /** PhraseId currently hovered anywhere in the interlinearizer; shared across all SegmentViews. */
   hoveredPhraseId: string | undefined;
   /** Sets the hovered phraseId when the pointer enters or leaves a phrase box. */
@@ -90,12 +83,7 @@ type SegmentListViewProps = Readonly<{
  * @param props.reportSettled - Reports the window has settled; lifts the cross-book curtain.
  * @param props.phraseMode - Current phrase-interaction mode passed down for rendering.
  * @param props.setPhraseMode - Setter for `phraseMode`.
- * @param props.hideInactiveLinkButtons - When true, link buttons are hidden outside the active
- *   verse.
- * @param props.simplifyPhrases - When true, phrase controls are hidden except on the focused
- *   phrase.
- * @param props.chapterLabelInVerse - When true, every verse is labeled `chapter:verse` instead of
- *   showing an inline chapter header.
+ * @param props.viewOptions - Bundled display toggles forwarded unchanged to each segment.
  * @param props.hoveredPhraseId - PhraseId currently hovered anywhere in the interlinearizer.
  * @param props.setHoveredPhraseId - Sets the hovered phraseId.
  * @param props.editPhraseSegmentId - Segment id containing the phrase being edited, or `undefined`.
@@ -116,9 +104,7 @@ export default function SegmentListView({
   reportSettled,
   phraseMode,
   setPhraseMode,
-  hideInactiveLinkButtons,
-  simplifyPhrases,
-  chapterLabelInVerse,
+  viewOptions,
   hoveredPhraseId,
   setHoveredPhraseId,
   editPhraseSegmentId,
@@ -127,6 +113,10 @@ export default function SegmentListView({
   tokenDocOrder,
   wordTokenByRef,
 }: SegmentListViewProps) {
+  // Read directly here for the inline chapter headers; the rest of `viewOptions` is forwarded
+  // unchanged to each SegmentView.
+  const { chapterLabelInVerse } = viewOptions;
+
   /**
    * Ids of the segments that begin a new chapter — the first segment of the book and every segment
    * whose chapter differs from the immediately preceding segment in book order. Computed over the
@@ -247,9 +237,7 @@ export default function SegmentListView({
                   tokenSegmentMap={tokenSegmentMap}
                   tokenDocOrder={tokenDocOrder}
                   wordTokenByRef={wordTokenByRef}
-                  hideInactiveLinkButtons={hideInactiveLinkButtons}
-                  simplifyPhrases={simplifyPhrases}
-                  chapterLabelInVerse={chapterLabelInVerse}
+                  viewOptions={viewOptions}
                 />
               </Fragment>
             ))}
diff --git a/src/components/SegmentView.tsx b/src/components/SegmentView.tsx
index 493f1dcb..e4e0c14e 100644
--- a/src/components/SegmentView.tsx
+++ b/src/components/SegmentView.tsx
@@ -11,6 +11,7 @@ import {
   usePhraseStripContextValue,
 } from '../hooks/usePhraseStripSetup';
 import type { PhraseMode } from '../types/phrase-mode';
+import type { ViewOptions } from '../types/view-options';
 import type { RenderUnit } from '../types/token-layout';
 import { buildRenderUnits, groupTokens, resolveFocusContext } from '../utils/token-layout';
 import { usePhraseLinkByIdMap, usePhraseLinkMap } from './AnalysisStore';
@@ -74,21 +75,11 @@ type SegmentViewProps = Readonly<{
   /** Word token ref → token lookup for the whole book; used to resolve focus context. */
   wordTokenByRef: ReadonlyMap<string, Token & { type: 'word' }>;
   /**
-   * When `true`, the link/unlink buttons between phrase boxes are hidden unless this segment is the
-   * active verse. Passed through to {@link PhraseStripContextValue}.
+   * Bundled display toggles. `hideInactiveLinkButtons`, `simplifyPhrases`, and `showMorphology` are
+   * passed through to {@link PhraseStripContextValue}; `chapterLabelInVerse` controls this segment's
+   * verse label.
    */
-  hideInactiveLinkButtons: boolean;
-  /**
-   * When `true`, phrase-level controls (split, intra-phrase unlink, remove-token) are hidden on
-   * every phrase except the focused one. Passed through to {@link PhraseStripContextValue}.
-   */
-  simplifyPhrases: boolean;
-  /**
-   * When `true`, every segment is labeled `chapter:verse`. When `false`, segments show a bare verse
-   * number (the chapter is shown by an inline header that {@link SegmentListView} renders above each
-   * chapter's first segment).
-   */
-  chapterLabelInVerse: boolean;
+  viewOptions: ViewOptions;
 }>;
 
 /**
@@ -116,12 +107,8 @@ type SegmentViewProps = Readonly<{
  * @param props.tokenDocOrder - Book-level map from word token ref to flat document index; used to
  *   sort phrase tokens across segment boundaries.
  * @param props.wordTokenByRef - Word token ref → token lookup; used to resolve focus context.
- * @param props.hideInactiveLinkButtons - When true, link buttons between phrases are hidden unless
- *   this segment is the active verse.
- * @param props.simplifyPhrases - When true, phrase-level controls are hidden on every phrase except
- *   the focused one.
- * @param props.chapterLabelInVerse - When true, every segment is labeled `chapter:verse`; when
- *   false, segments show a bare verse number.
+ * @param props.viewOptions - Bundled display toggles; `chapterLabelInVerse` sets the verse label,
+ *   the rest pass through to the phrase strip context.
  * @returns A button (baseline-text mode) or div (token-chip mode) containing a verse label and
  *   segment content
  */
@@ -139,10 +126,10 @@ export function SegmentView({
   tokenSegmentMap,
   tokenDocOrder,
   wordTokenByRef,
-  hideInactiveLinkButtons,
-  simplifyPhrases,
-  chapterLabelInVerse,
+  viewOptions,
 }: SegmentViewProps) {
+  const { hideInactiveLinkButtons, simplifyPhrases, chapterLabelInVerse, showMorphology } =
+    viewOptions;
   const { book, chapter, verse } = segment.startRef;
   const ref: ScriptureRef = useMemo(() => ({ book, chapter, verse }), [book, chapter, verse]);
 
@@ -321,6 +308,7 @@ export function SegmentView({
     crossSegmentLinkTooltip:
       localizedStrings['%interlinearizer_linkButton_crossSegmentDisabledTooltip%'],
     skipLinkTransition: !hasMounted,
+    showMorphology,
   });
 
   /** True when any committed phrase exists in this segment. */
diff --git a/src/components/TokenChip.tsx b/src/components/TokenChip.tsx
index 4d5ba172..7e3f4cfe 100644
--- a/src/components/TokenChip.tsx
+++ b/src/components/TokenChip.tsx
@@ -1,7 +1,22 @@
 import type { Token } from 'interlinearizer';
+import { useLocalizedStrings } from '@papi/frontend/react';
 import { X } from 'lucide-react';
-import { memo, type MouseEventHandler, useEffect, useRef, useState } from 'react';
-import { useGloss, useGlossDispatch } from './AnalysisStore';
+import { Popover, PopoverAnchor } from 'platform-bible-react';
+import { memo, type MouseEventHandler, useEffect, useId, useRef, useState } from 'react';
+import {
+  useAnalysisLanguage,
+  useGloss,
+  useGlossDispatch,
+  useMorphemeBreakdownDispatch,
+  useMorphemeDeleteDispatch,
+  useMorphemes,
+} from './AnalysisStore';
+import { MorphemeBreakdownPopover, MorphemeGlossInput } from './MorphemeEditor';
+
+const STRING_KEYS = [
+  '%interlinearizer_tokenChip_editMorphemes%',
+  '%interlinearizer_tokenChip_defineMorphemes%',
+] as const satisfies `%${string}%`[];
 
 /**
  * Renders a single word token as an inline chip with an editable gloss input below the surface
@@ -10,15 +25,22 @@ import { useGloss, useGlossDispatch } from './AnalysisStore';
  * only when the draft differs from the committed value, to avoid creating empty analysis entries on
  * focus/blur cycles with no edits.
  *
+ * When `showMorphology` is true, a morpheme row is shown below the surface text. For unanalyzed
+ * tokens this is a clickable button showing the surface text; for analyzed tokens it shows the
+ * morpheme forms. Clicking either opens an inline popover where the user can define, edit, or
+ * delete the morpheme breakdown. Per-morpheme gloss inputs appear below the morpheme forms.
+ *
  * @param props - Component props
  * @param props.token - The word token to render.
  * @param props.onFocus - Called when the gloss input receives focus.
  * @param props.disabled - When true, the gloss input is read-only and non-interactive.
- * @param props.onRemove - When provided, renders a small ✕ button in the top-right corner of the
+ * @param props.onRemove - When provided, renders a small X button in the top-right corner of the
  *   chip; clicking it calls this callback to remove the token from its phrase.
  * @param props.isSplitFree - When true, this token would become free (solo) if the currently
  *   hovered split/unlink button were clicked; previewed with a destructive border on the chip.
- * @returns A styled label containing the surface text and a gloss input.
+ * @param props.showMorphology - When true, morpheme breakdown and per-morpheme glosses are shown
+ *   below the surface text.
+ * @returns A styled label containing the surface text, optionally morpheme rows, and a gloss input.
  */
 export function TokenChip({
   token,
@@ -26,16 +48,25 @@ export function TokenChip({
   disabled = false,
   onRemove,
   isSplitFree = false,
+  showMorphology = false,
 }: Readonly<{
   token: Token & { type: 'word' };
   onFocus: () => void;
   disabled?: boolean;
   onRemove?: () => void;
   isSplitFree?: boolean;
+  showMorphology?: boolean;
 }>) {
+  const [localizedStrings] = useLocalizedStrings(STRING_KEYS);
   const committedGloss = useGloss(token.ref);
   const onGlossChange = useGlossDispatch();
+  const morphemes = useMorphemes(token.ref);
+  const analysisLanguage = useAnalysisLanguage();
+  const dispatchMorphemeBreakdown = useMorphemeBreakdownDispatch();
+  const dispatchMorphemeDelete = useMorphemeDeleteDispatch();
   const [draft, setDraft] = useState(committedGloss);
+  const [popoverOpen, setPopoverOpen] = useState(false);
+  const glossInputId = useId();
   // Tracks whether the X button itself is hovered, so only that button hover reddens the border.
   const [isRemoveHovered, setIsRemoveHovered] = useState(false);
   // Reset remove-hover state when onRemove is cleared so the red border doesn't linger.
@@ -52,6 +83,15 @@ export function TokenChip({
     setDraft(committedGloss);
   }, [committedGloss]);
 
+  // The popover tree unmounts with the morpheme row when showMorphology turns off, but this state
+  // lives on the chip and would survive — silently reopening the popover when morphology is shown
+  // again. Clearing it on hide also closes the popover. We also close it when the chip becomes
+  // disabled: the popover content renders on `popoverOpen` alone (it isn't gated on `disabled`), so
+  // a chip whose popover is open while it transitions to disabled would otherwise stay editable.
+  useEffect(() => {
+    if (!showMorphology || disabled) setPopoverOpen(false);
+  }, [showMorphology, disabled]);
+
   const handleMouseDown: MouseEventHandler<HTMLInputElement> = (e) => {
     // Prevent the browser's built-in focus-and-scroll so only the React-controlled
     // smooth scrollIntoView fires. We re-focus manually with preventScroll instead.
@@ -64,20 +104,39 @@ export function TokenChip({
    * activation — which forwards focus to the gloss input with the browser's default
    * scroll-into-view — can never scroll the list under the click. Focuses the input directly with
    * `preventScroll` instead; the native forwarding then finds it already focused and does nothing.
-   * A mouse-down on the input itself is left to {@link handleMouseDown}, which bubbles here after
-   * already handling it.
+   * The input is looked up by id rather than `querySelector('input')` because the morpheme gloss
+   * inputs precede it inside the label when morphology is shown. A mouse-down on any input is left
+   * to that input's own handling ({@link handleMouseDown} for the gloss input, which bubbles here
+   * after already handling it); a mouse-down on the morpheme trigger button is left to the button's
+   * own click handler, which opens the popover.
    *
    * @param e - The label's mouse-down event.
    */
   const handleLabelMouseDown: MouseEventHandler<HTMLLabelElement> = (e) => {
-    if (e.target instanceof Element && e.target.closest('input')) return;
+    if (e.target instanceof Element && e.target.closest('input, button')) return;
     e.preventDefault();
-    e.currentTarget.querySelector('input')?.focus({ preventScroll: true });
+    document.getElementById(glossInputId)?.focus({ preventScroll: true });
   };
 
-  // The X button is positioned outside the <label> so its implicit labeled control stays the gloss
-  // input, not the button. Otherwise clicking anywhere on the chip (label-association behavior)
-  // would trigger the X button instead of focusing the input.
+  /**
+   * Commits the morpheme breakdown from the popover input, splitting on whitespace.
+   *
+   * @param value - The raw text from the popover input.
+   */
+  const handleMorphemeSave = (value: string) => {
+    const forms = value.split(/\s+/).filter(Boolean);
+    if (forms.length > 0) {
+      dispatchMorphemeBreakdown(token.ref, token.surfaceText, forms, token.writingSystem);
+    }
+  };
+
+  const hasMorphemes = morphemes.length > 0;
+
+  // The X button is positioned outside the <label>, and the label is bound to the gloss input with
+  // an explicit htmlFor, so clicking the chip body always focuses the gloss input. Without the
+  // explicit binding, the label's implicit control would be its first labelable descendant — the X
+  // button, or the morpheme trigger button when showMorphology is on — and clicking anywhere on
+  // the chip (label-association behavior) would activate that button instead.
   return (
     <span className="tw:relative tw:inline-flex tw:shrink-0">
       {onRemove && (
@@ -99,14 +158,85 @@ export function TokenChip({
       <label
         className={`tw:inline-flex tw:flex-col tw:items-center tw:rounded tw:border tw:bg-muted tw:px-1.5 tw:py-0.5${isRemoveHovered || isSplitFree ? ' tw:border-destructive' : ' tw:border-border'}${disabled ? ' tw:pointer-events-none' : ''}`}
         onMouseDown={disabled ? undefined : handleLabelMouseDown}
+        htmlFor={glossInputId}
       >
         <span className="tw:whitespace-nowrap tw:font-mono tw:text-sm tw:text-foreground tw:cursor-text">
           {token.surfaceText}
         </span>
+        {showMorphology && (
+          // The morpheme row is the popover anchor; the panel itself is portaled to document.body
+          // by PopoverContent, so it escapes both the clipping of ancestor scroll viewports (e.g.
+          // the continuous view's token strip) and the `token-row` stacking contexts that would
+          // otherwise paint later segment rows over it. The popover is modal so interactions
+          // outside the panel are blocked while it is open. The popover component is mounted only
+          // while open so its draft state re-initializes from the current forms on every open.
+          //
+          // `onOpenChange` is intentionally omitted: this consumer owns every dismissal path
+          // (onEscapeKeyDown, onInteractOutside, explicit button clicks), so Radix's internal close
+          // requests aren't needed. Don't wire onOpenChange without also removing those, or closes
+          // would double-fire.
+          <Popover modal open={popoverOpen}>
+            <PopoverAnchor asChild>
+              <div className="tw:relative tw:flex tw:flex-col tw:items-center tw:w-full">
+                <button
+                  aria-label={(hasMorphemes
+                    ? localizedStrings['%interlinearizer_tokenChip_editMorphemes%']
+                    : localizedStrings['%interlinearizer_tokenChip_defineMorphemes%']
+                  ).replace('{token}', token.surfaceText)}
+                  className={`tw:flex tw:flex-row tw:gap-0.5 tw:items-center tw:rounded tw:px-0.5 tw:transition-colors${disabled ? '' : ' tw:cursor-pointer tw:hover:bg-accent'} ${hasMorphemes ? 'tw:text-muted-foreground' : 'tw:text-muted-foreground/50 tw:italic'}`}
+                  tabIndex={-1}
+                  type="button"
+                  onClick={(e) => {
+                    e.preventDefault();
+                    if (!disabled) setPopoverOpen(true);
+                  }}
+                >
+                  {hasMorphemes ? (
+                    morphemes.map((m) => (
+                      <span key={m.id} className="tw:whitespace-nowrap tw:font-mono tw:text-xs">
+                        {m.form}
+                      </span>
+                    ))
+                  ) : (
+                    <span className="tw:whitespace-nowrap tw:font-mono tw:text-xs">
+                      {token.surfaceText}
+                    </span>
+                  )}
+                </button>
+                {hasMorphemes && (
+                  <span className="tw:flex tw:flex-row tw:gap-0.5">
+                    {morphemes.map((m) => (
+                      <MorphemeGlossInput
+                        key={m.id}
+                        analysisLanguage={analysisLanguage}
+                        disabled={disabled}
+                        morpheme={m}
+                        tokenRef={token.ref}
+                      />
+                    ))}
+                  </span>
+                )}
+              </div>
+            </PopoverAnchor>
+            {popoverOpen && (
+              <MorphemeBreakdownPopover
+                glossInputId={glossInputId}
+                initialValue={
+                  hasMorphemes ? morphemes.map((m) => m.form).join(' ') : token.surfaceText
+                }
+                onClose={() => setPopoverOpen(false)}
+                onDelete={hasMorphemes ? () => dispatchMorphemeDelete(token.ref) : undefined}
+                onSave={handleMorphemeSave}
+                surfaceText={token.surfaceText}
+              />
+            )}
+          </Popover>
+        )}
         <input
           aria-label={`Gloss for ${token.surfaceText}`}
           className="tw:gloss-input"
           disabled={disabled}
+          id={glossInputId}
           placeholder="gloss"
           style={{ fieldSizing: 'content', minWidth: '5ch' }}
           value={draft}
diff --git a/src/components/__mocks__/AnalysisStore.tsx b/src/components/__mocks__/AnalysisStore.tsx
index fc59350a..d32e2bb0 100644
--- a/src/components/__mocks__/AnalysisStore.tsx
+++ b/src/components/__mocks__/AnalysisStore.tsx
@@ -2,14 +2,15 @@
 
 import { createContext, useCallback, useContext, useMemo, useState } from 'react';
 import type { ReactNode } from 'react';
-import type { AssignmentStatus } from 'interlinearizer';
+import type { AssignmentStatus, MorphemeAnalysis } from 'interlinearizer';
 
 type GlossMap = Record<string, string>;
 type MockCtxValue = {
   glosses: GlossMap;
   dispatch: (tokenRef: string, surfaceText: string, value: string) => void;
+  language: string;
 };
-const MockCtx = createContext<MockCtxValue>({ glosses: {}, dispatch: () => {} });
+const MockCtx = createContext<MockCtxValue>({ glosses: {}, dispatch: () => {}, language: 'und' });
 
 /**
  * Test-only provider that seeds glosses from `initialAnalysis` and keeps them in local state,
@@ -51,7 +52,10 @@ export function AnalysisStoreProvider({
     },
     [onGlossChange],
   );
-  const ctx = useMemo(() => ({ glosses, dispatch }), [glosses, dispatch]);
+  const ctx = useMemo(
+    () => ({ glosses, dispatch, language: analysisLanguage }),
+    [glosses, dispatch, analysisLanguage],
+  );
   return <MockCtx value={ctx}>{children}</MockCtx>;
 }
 
@@ -73,3 +77,62 @@ export function useGloss(tokenRef: string) {
 export function useGlossDispatch() {
   return useContext(MockCtx).dispatch;
 }
+
+/** Empty morphemes array returned by {@link useMorphemes} when no breakdown exists. */
+const EMPTY_MORPHEMES: readonly MorphemeAnalysis[] = [];
+
+/**
+ * Returns the morpheme breakdown for a token. Always returns an empty array in mock context.
+ *
+ * @param _tokenRef - The token reference key (unused in mock).
+ * @returns An empty readonly morpheme array.
+ */
+export function useMorphemes(_tokenRef: string): readonly MorphemeAnalysis[] {
+  return EMPTY_MORPHEMES;
+}
+
+/**
+ * Returns the analysis language string from mock context, mirroring the `analysisLanguage` prop
+ * passed to the mock provider.
+ *
+ * @returns The BCP 47 tag from mock context (defaults to `'und'` outside a provider).
+ */
+export function useAnalysisLanguage(): string {
+  return useContext(MockCtx).language;
+}
+
+/**
+ * Returns a no-op dispatch for writing morpheme breakdowns in mock context.
+ *
+ * @returns A no-op function matching the real signature.
+ */
+export function useMorphemeBreakdownDispatch(): (
+  tokenRef: string,
+  surfaceText: string,
+  forms: string[],
+  writingSystem: string,
+) => void {
+  return () => {};
+}
+
+/**
+ * Returns a no-op dispatch for deleting morpheme breakdowns in mock context.
+ *
+ * @returns A no-op function matching the real signature.
+ */
+export function useMorphemeDeleteDispatch(): (tokenRef: string) => void {
+  return () => {};
+}
+
+/**
+ * Returns a no-op dispatch for writing morpheme glosses in mock context.
+ *
+ * @returns A no-op function matching the real signature.
+ */
+export function useMorphemeGlossDispatch(): (
+  tokenRef: string,
+  morphemeId: string,
+  value: string,
+) => void {
+  return () => {};
+}
diff --git a/src/components/controls/ViewOptionsDropdown.tsx b/src/components/controls/ViewOptionsDropdown.tsx
index 2d09a747..51010bed 100644
--- a/src/components/controls/ViewOptionsDropdown.tsx
+++ b/src/components/controls/ViewOptionsDropdown.tsx
@@ -10,6 +10,7 @@ const STRING_KEYS = [
   '%interlinearizer_viewOption_hideInactiveLinkButtons%',
   '%interlinearizer_viewOption_simplifyPhrases%',
   '%interlinearizer_viewOption_chapterLabelInVerse%',
+  '%interlinearizer_viewOption_showMorphology%',
 ] as const satisfies `%${string}%`[];
 
 /**
@@ -62,12 +63,16 @@ type ViewOptionsDropdownProps = Readonly<{
   chapterLabelInVerse: boolean;
   /** Called when the show-chapter-in-verse-label toggle changes. */
   onChapterLabelInVerseChange: (checked: boolean) => void;
+  /** Current value of the show-morphology toggle. */
+  showMorphology: boolean;
+  /** Called when the show-morphology toggle changes. */
+  onShowMorphologyChange: (checked: boolean) => void;
 }>;
 
 /**
- * Toolbar dropdown that groups the continuous-scroll toggle and three view-mode toggles (hide
- * inactive link buttons, simplify phrases, chapter label in verse). Opens and closes via a gear
- * icon button.
+ * Toolbar dropdown that groups the continuous-scroll toggle and four view-mode toggles (show
+ * morphology, hide inactive link buttons, simplify phrases, chapter label in verse). Opens and
+ * closes via a gear icon button.
  *
  * @param props - Component props
  * @param props.continuousScroll - Current continuous-scroll value.
@@ -78,6 +83,8 @@ type ViewOptionsDropdownProps = Readonly<{
  * @param props.onSimplifyPhrasesChange - Dim-inactive-segments change callback.
  * @param props.chapterLabelInVerse - Current show-chapter-in-verse-label value.
  * @param props.onChapterLabelInVerseChange - Show-chapter-in-verse-label change callback.
+ * @param props.showMorphology - Current show-morphology value.
+ * @param props.onShowMorphologyChange - Show-morphology change callback.
  * @returns A gear button that opens a dropdown panel of view toggles.
  */
 export default function ViewOptionsDropdown({
@@ -89,6 +96,8 @@ export default function ViewOptionsDropdown({
   onSimplifyPhrasesChange,
   chapterLabelInVerse,
   onChapterLabelInVerseChange,
+  showMorphology,
+  onShowMorphologyChange,
 }: ViewOptionsDropdownProps) {
   const [localizedStrings] = useLocalizedStrings(STRING_KEYS);
   const [open, setOpen] = useState(false);
@@ -177,6 +186,11 @@ export default function ViewOptionsDropdown({
                 label={localizedStrings['%interlinearizer_viewOption_continuousScroll%']}
                 onCheckedChange={onContinuousScrollChange}
               />
+              <ViewToggle
+                checked={showMorphology}
+                label={localizedStrings['%interlinearizer_viewOption_showMorphology%']}
+                onCheckedChange={onShowMorphologyChange}
+              />
               <ViewToggle
                 checked={hideInactiveLinkButtons}
                 label={localizedStrings['%interlinearizer_viewOption_hideInactiveLinkButtons%']}
diff --git a/src/hooks/usePhraseStripSetup.ts b/src/hooks/usePhraseStripSetup.ts
index f584caba..e09e0303 100644
--- a/src/hooks/usePhraseStripSetup.ts
+++ b/src/hooks/usePhraseStripSetup.ts
@@ -121,6 +121,8 @@ export type PhraseStripContextParams = Readonly<{
   crossSegmentLinkTooltip: string;
   /** When true, the link-slot sliding-door transition is suppressed (duration 0ms). */
   skipLinkTransition: boolean;
+  /** When true, morpheme rows and per-morpheme glosses are shown beneath each word token. */
+  showMorphology: boolean;
 }>;
 
 /**
@@ -151,6 +153,7 @@ export function usePhraseStripContextValue(
     activeSegmentId,
     crossSegmentLinkTooltip,
     skipLinkTransition,
+    showMorphology,
   } = params;
 
   return useMemo<PhraseStripContextValue>(
@@ -169,6 +172,7 @@ export function usePhraseStripContextValue(
       activeSegmentId,
       crossSegmentLinkTooltip,
       skipLinkTransition,
+      showMorphology,
     }),
     [
       phraseMode,
@@ -185,6 +189,7 @@ export function usePhraseStripContextValue(
       activeSegmentId,
       crossSegmentLinkTooltip,
       skipLinkTransition,
+      showMorphology,
     ],
   );
 }
diff --git a/src/main.ts b/src/main.ts
index 3ab484df..4c2beb5d 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -362,24 +362,40 @@ export async function activate(context: ExecutionActivationContext): Promise<voi
     },
   );
 
+  /**
+   * Returns whether the supplied project-setting value is a boolean.
+   *
+   * @param newValue - Candidate project-setting value.
+   * @returns A promise that resolves to `true` when `newValue` is a boolean.
+   */
+  /* v8 ignore next 3 */
+  function isBoolean(newValue: unknown): Promise<boolean> {
+    return Promise.resolve(typeof newValue === 'boolean');
+  }
+
   const continuousScrollValidatorRegistration = await papi.projectSettings.registerValidator(
     'interlinearizer.continuousScroll',
-    async (newValue) => typeof newValue === 'boolean',
+    isBoolean,
   );
 
   const hideInactiveLinkButtonsValidatorRegistration = await papi.projectSettings.registerValidator(
     'interlinearizer.hideInactiveLinkButtons',
-    async (newValue) => typeof newValue === 'boolean',
+    isBoolean,
   );
 
   const simplifyPhrasesValidatorRegistration = await papi.projectSettings.registerValidator(
     'interlinearizer.simplifyPhrases',
-    async (newValue) => typeof newValue === 'boolean',
+    isBoolean,
   );
 
   const chapterLabelInVerseValidatorRegistration = await papi.projectSettings.registerValidator(
     'interlinearizer.chapterLabelInVerse',
-    async (newValue) => typeof newValue === 'boolean',
+    isBoolean,
+  );
+
+  const showMorphologyValidatorRegistration = await papi.projectSettings.registerValidator(
+    'interlinearizer.showMorphology',
+    isBoolean,
   );
 
   const createProjectCommandRegistration = await papi.commands.registerCommand(
@@ -630,6 +646,7 @@ export async function activate(context: ExecutionActivationContext): Promise<voi
     hideInactiveLinkButtonsValidatorRegistration,
     simplifyPhrasesValidatorRegistration,
     chapterLabelInVerseValidatorRegistration,
+    showMorphologyValidatorRegistration,
     createProjectCommandRegistration,
     getProjectCommandRegistration,
     saveAnalysisCommandRegistration,
diff --git a/src/store/analysisSlice.ts b/src/store/analysisSlice.ts
index 0218964f..e8fb5728 100644
--- a/src/store/analysisSlice.ts
+++ b/src/store/analysisSlice.ts
@@ -1,5 +1,6 @@
 import { createSelector, createSlice, type PayloadAction } from '@reduxjs/toolkit';
 import type {
+  MorphemeAnalysis,
   PhraseAnalysis,
   PhraseAnalysisLink,
   TextAnalysis,
@@ -113,6 +114,104 @@ function removePhraseById(state: AnalysisState, phraseId: string): void {
   );
 }
 
+/**
+ * Finds the approved `TokenAnalysisLink` for `tokenRef` together with the `TokenAnalysis` it
+ * references. When the approved link references a missing analysis (an orphaned link from
+ * corruption or a migration), the link is removed from the draft — so the corruption never persists
+ * or accumulates duplicate approved links — and `undefined` is returned as if no approved link
+ * existed. Every token-analysis reducer resolves through this helper so they all repair orphaned
+ * links the same way.
+ *
+ * @param state - Current slice state (Immer draft).
+ * @param tokenRef - `Token.ref` of the token to look up.
+ * @returns The approved link and its analysis, or `undefined` when the token has none.
+ */
+function resolveApprovedAnalysis(
+  state: AnalysisState,
+  tokenRef: string,
+): { link: TokenAnalysisLink; analysis: TokenAnalysis } | undefined {
+  const link = state.analysis.tokenAnalysisLinks.find(
+    (l) => l.status === 'approved' && l.token.tokenRef === tokenRef,
+  );
+  if (!link) return undefined;
+  const analysis = state.analysis.tokenAnalyses.find((ta) => ta.id === link.analysisId);
+  if (!analysis) {
+    state.analysis.tokenAnalysisLinks = state.analysis.tokenAnalysisLinks.filter((l) => l !== link);
+    return undefined;
+  }
+  return { link, analysis };
+}
+
+/**
+ * Appends a new `TokenAnalysis` and an approved `TokenAnalysisLink` referencing it in a single
+ * step, ensuring both collections stay in sync. The link's token snapshot takes its surface text
+ * from the analysis.
+ *
+ * @param state - Current slice state (Immer draft).
+ * @param analysis - The new `TokenAnalysis` record to append.
+ * @param tokenRef - `Token.ref` of the token the link points at.
+ */
+function appendApprovedAnalysis(
+  state: AnalysisState,
+  analysis: TokenAnalysis,
+  tokenRef: string,
+): void {
+  state.analysis.tokenAnalyses.push(analysis);
+  state.analysis.tokenAnalysisLinks.push({
+    analysisId: analysis.id,
+    status: 'approved',
+    token: { tokenRef, surfaceText: analysis.surfaceText },
+  });
+}
+
+/**
+ * Removes a `TokenAnalysis` record and its `TokenAnalysisLink` from the draft in a single step,
+ * keeping the two collections in sync. Called when an edit empties an analysis of all content so
+ * empty records do not accumulate in storage.
+ *
+ * @param state - Current slice state (Immer draft).
+ * @param analysis - The `TokenAnalysis` record to remove.
+ * @param link - The `TokenAnalysisLink` referencing it.
+ */
+function removeTokenAnalysis(
+  state: AnalysisState,
+  analysis: TokenAnalysis,
+  link: TokenAnalysisLink,
+): void {
+  state.analysis.tokenAnalyses = state.analysis.tokenAnalyses.filter((ta) => ta !== analysis);
+  state.analysis.tokenAnalysisLinks = state.analysis.tokenAnalysisLinks.filter((l) => l !== link);
+}
+
+/**
+ * Determines whether a `TokenAnalysis` carries no analysis content, so a reducer that just emptied
+ * one field can decide to drop the whole record instead of letting empty records accumulate in
+ * storage. Checks every content field of the type — `gloss`, `morphemes`, `pos`, `features`, and
+ * `glossSenseRef` — not only the field the caller emptied, so records carrying imported
+ * morphosyntactic or lexicon data are never discarded by an unrelated edit. A gloss counts as empty
+ * when it has no entries or every entry is blank, so a record left holding only whitespace glosses
+ * (junk from clearing a gloss field) is treated the same as one with no gloss at all.
+ *
+ * Provenance fields (`confidence`, `producer`, `sourceUser`) are intentionally NOT treated as
+ * content: they describe who/what produced an analysis, not an analysis worth keeping on their own.
+ * A record holding only provenance and no glosses/morphemes/pos/features is therefore considered
+ * empty and may be dropped when its last content field is cleared. This is a deliberate choice — if
+ * a future workflow needs provenance-only records (e.g. imported parser metadata) to survive a
+ * gloss clear, add the relevant fields to the check below.
+ *
+ * @param analysis - The `TokenAnalysis` to inspect.
+ * @returns `true` when the record holds no analysis content worth keeping.
+ */
+function isEmptyTokenAnalysis(analysis: TokenAnalysis): boolean {
+  return (
+    (!analysis.gloss || Object.values(analysis.gloss).every((g) => g.trim() === '')) &&
+    /* v8 ignore next -- the length===0 sub-branch needs an empty-but-defined morphemes array, which no caller produces */
+    (!analysis.morphemes || analysis.morphemes.length === 0) &&
+    analysis.pos === undefined &&
+    analysis.features === undefined &&
+    analysis.glossSenseRef === undefined
+  );
+}
+
 const analysisSlice = createSlice({
   name: 'analysis',
   initialState: defaultState,
@@ -142,9 +241,18 @@ const analysisSlice = createSlice({
       },
       /**
        * Creates or updates an approved `TokenAnalysis` for the given token. If an approved link
-       * already exists for `tokenRef`, its analysis is updated in place; otherwise a new
-       * `TokenAnalysis` and `TokenAnalysisLink` are appended. Non-approved analyses for the token
-       * are left untouched.
+       * already exists for `tokenRef`, its analysis is updated in place and the stored surface text
+       * is refreshed on both the analysis and the link's token snapshot, so neither goes stale when
+       * the baseline text changed since the analysis was first written. Otherwise a new
+       * `TokenAnalysis` and `TokenAnalysisLink` are appended (an orphaned approved link is repaired
+       * first; see {@link resolveApprovedAnalysis}). Non-approved analyses for the token are left
+       * untouched.
+       *
+       * A blank `value` (empty or whitespace) is treated as clearing the gloss rather than writing
+       * junk: the active language's entry is removed, and when that leaves the analysis with no
+       * content ({@link isEmptyTokenAnalysis}) the record and its link are removed entirely. A blank
+       * write to a token with no approved analysis is a no-op, so a focus/blur cycle on an empty
+       * gloss never creates a record.
        *
        * @param state - Current slice state (Immer draft).
        * @param action - Action carrying the `WriteGlossPayload`.
@@ -152,38 +260,171 @@ const analysisSlice = createSlice({
       reducer(state, action: PayloadAction<WriteGlossPayload>) {
         const { tokenRef, surfaceText, value, id } = action.payload;
         const lang = state.analysisLanguage;
-
-        const existingLink = state.analysis.tokenAnalysisLinks.find(
-          (l) => l.status === 'approved' && l.token.tokenRef === tokenRef,
-        );
-
-        if (existingLink) {
-          const existingAnalysis = state.analysis.tokenAnalyses.find(
-            (ta) => ta.id === existingLink.analysisId,
-          );
-          if (existingAnalysis) {
-            existingAnalysis.surfaceText = surfaceText;
-            if (!existingAnalysis.gloss) existingAnalysis.gloss = {};
-            existingAnalysis.gloss[lang] = value;
+        const isBlank = value.trim() === '';
+
+        const resolved = resolveApprovedAnalysis(state, tokenRef);
+        if (resolved) {
+          const { link, analysis } = resolved;
+          analysis.surfaceText = surfaceText;
+          link.token.surfaceText = surfaceText;
+          if (isBlank) {
+            if (analysis.gloss) {
+              delete analysis.gloss[lang];
+              if (Object.keys(analysis.gloss).length === 0) delete analysis.gloss;
+            }
+            if (isEmptyTokenAnalysis(analysis)) removeTokenAnalysis(state, analysis, link);
             return;
           }
-          // The approved link references a missing analysis (orphaned link from corruption or a
-          // migration). Remove it so we don't accumulate duplicate approved links below.
-          state.analysis.tokenAnalysisLinks = state.analysis.tokenAnalysisLinks.filter(
-            (l) => l !== existingLink,
-          );
+          if (!analysis.gloss) analysis.gloss = {};
+          analysis.gloss[lang] = value;
+          return;
         }
 
-        // No approved link exists, or the orphaned link was removed above — create a new one.
-        const newAnalysis: TokenAnalysis = { id, surfaceText, gloss: { [lang]: value } };
-        const newLink: TokenAnalysisLink = {
-          analysisId: id,
-          status: 'approved',
-          token: { tokenRef, surfaceText },
+        if (isBlank) return;
+        appendApprovedAnalysis(state, { id, surfaceText, gloss: { [lang]: value } }, tokenRef);
+      },
+    },
+    writeMorphemes: {
+      /**
+       * Generates UUIDs for new morpheme records and a potential new `TokenAnalysis` before the
+       * action reaches the reducer.
+       *
+       * @param tokenRef - `Token.ref` of the token whose morphemes are being set.
+       * @param surfaceText - Surface text of the token.
+       * @param forms - Ordered morpheme form strings as entered by the user.
+       * @param writingSystem - BCP 47 tag of the token's surface text (`Token.writingSystem`),
+       *   stored on each morpheme as the writing system of its form.
+       * @returns The prepared action payload.
+       */
+      prepare(tokenRef: string, surfaceText: string, forms: string[], writingSystem: string) {
+        return {
+          payload: {
+            tokenRef,
+            surfaceText,
+            writingSystem,
+            analysisId: crypto.randomUUID(),
+            morphemes: forms.map((form) => ({ id: crypto.randomUUID(), form })),
+          },
         };
-        state.analysis.tokenAnalyses.push(newAnalysis);
-        state.analysis.tokenAnalysisLinks.push(newLink);
       },
+      /**
+       * Sets the morpheme breakdown on the approved `TokenAnalysis` for the given token. When a
+       * morpheme form is unchanged the existing morpheme record is preserved whole — including its
+       * id, which `MorphemeLink.morphemeId` cross-references, so alignment links to unchanged
+       * morphemes survive edits to the rest of the breakdown. When no approved analysis exists,
+       * creates one (an orphaned approved link is repaired first; see
+       * {@link resolveApprovedAnalysis}). Also refreshes the stored surface text on both the
+       * analysis and the link's token snapshot, so neither goes stale when the baseline text
+       * changed since the analysis was first written. Every morpheme — preserved or new — is
+       * stamped with the supplied writing system, so records written before the writing system was
+       * threaded through (which wrongly stored the analysis language) self-correct on the next
+       * save.
+       *
+       * @param state - Current slice state (Immer draft).
+       * @param action - Action carrying the morpheme payload.
+       */
+      reducer(
+        state,
+        action: PayloadAction<{
+          tokenRef: string;
+          surfaceText: string;
+          writingSystem: string;
+          analysisId: string;
+          morphemes: Array<{ id: string; form: string }>;
+        }>,
+      ) {
+        const { tokenRef, surfaceText, writingSystem, analysisId, morphemes } = action.payload;
+
+        const resolved = resolveApprovedAnalysis(state, tokenRef);
+        if (resolved) {
+          const { link, analysis } = resolved;
+          analysis.surfaceText = surfaceText;
+          link.token.surfaceText = surfaceText;
+          // Multimap with consumed entries so duplicate forms (e.g. reduplication "ba ba") each
+          // match a distinct old morpheme in order, instead of all inheriting the last one.
+          const oldByForm = new Map<string, MorphemeAnalysis[]>();
+          (analysis.morphemes ?? []).forEach((m) => {
+            const bucket = oldByForm.get(m.form);
+            if (bucket) bucket.push(m);
+            else oldByForm.set(m.form, [m]);
+          });
+          analysis.morphemes = morphemes.map(({ id, form }) => {
+            const old = oldByForm.get(form)?.shift();
+            // Keep the preserved morpheme's id (the prepared id is discarded) so external
+            // references to it stay valid; only the writing system is refreshed.
+            if (old) return { ...old, writingSystem };
+            return { id, form, writingSystem };
+          });
+          return;
+        }
+
+        appendApprovedAnalysis(
+          state,
+          {
+            id: analysisId,
+            surfaceText,
+            morphemes: morphemes.map(({ id, form }) => ({ id, form, writingSystem })),
+          },
+          tokenRef,
+        );
+      },
+    },
+    /**
+     * Removes the morpheme breakdown from the approved `TokenAnalysis` for the given token. When
+     * the analysis carries no other content (gloss, POS, features, or lexicon sense reference — see
+     * {@link isEmptyTokenAnalysis}), the now-empty analysis record and its link are removed entirely
+     * so empty records do not accumulate in storage. No-ops when the token has no approved analysis
+     * or the analysis has no morphemes (an orphaned approved link is still repaired; see
+     * {@link resolveApprovedAnalysis}).
+     *
+     * @param state - Current slice state (Immer draft).
+     * @param action - Action carrying the `tokenRef` whose breakdown is removed.
+     */
+    deleteMorphemes(state, action: PayloadAction<{ tokenRef: string }>) {
+      const { tokenRef } = action.payload;
+
+      const resolved = resolveApprovedAnalysis(state, tokenRef);
+      if (!resolved?.analysis.morphemes) return;
+      const { link, analysis } = resolved;
+
+      delete analysis.morphemes;
+      if (isEmptyTokenAnalysis(analysis)) removeTokenAnalysis(state, analysis, link);
+    },
+    /**
+     * Writes a gloss string onto a single morpheme within the approved `TokenAnalysis` for the
+     * given token. No-ops when the token has no approved analysis or the morpheme id is not found
+     * (an orphaned approved link is still repaired; see {@link resolveApprovedAnalysis}).
+     *
+     * A blank `value` (empty or whitespace) clears the gloss rather than storing junk: the active
+     * language's entry is removed, and when that leaves the morpheme with no glosses the `gloss`
+     * object is dropped entirely — mirroring the token-level {@link writeGloss}. The morpheme record
+     * itself is kept (a breakdown is content in its own right), so unlike `writeGloss` this never
+     * removes the enclosing analysis.
+     *
+     * @param state - Current slice state (Immer draft).
+     * @param action - Action carrying the morpheme gloss payload.
+     */
+    writeMorphemeGloss(
+      state,
+      action: PayloadAction<{ tokenRef: string; morphemeId: string; value: string }>,
+    ) {
+      const { tokenRef, morphemeId, value } = action.payload;
+      const lang = state.analysisLanguage;
+
+      const resolved = resolveApprovedAnalysis(state, tokenRef);
+      const morpheme = resolved?.analysis.morphemes?.find((m) => m.id === morphemeId);
+      if (!morpheme) return;
+
+      if (value.trim() === '') {
+        if (morpheme.gloss) {
+          delete morpheme.gloss[lang];
+          if (Object.keys(morpheme.gloss).length === 0) delete morpheme.gloss;
+        }
+        return;
+      }
+
+      if (!morpheme.gloss) morpheme.gloss = {};
+      morpheme.gloss[lang] = value;
     },
     createPhrase: {
       /**
@@ -287,6 +528,9 @@ const analysisSlice = createSlice({
 export const {
   setAnalysis,
   writeGloss,
+  writeMorphemes,
+  deleteMorphemes,
+  writeMorphemeGloss,
   createPhrase,
   updatePhrase,
   deletePhrase,
@@ -321,7 +565,7 @@ const selectTokenAnalysisLinks = (state: AnalysisState) => state.analysis.tokenA
  * @param state - The analysis slice state.
  * @returns The active BCP 47 analysis language tag.
  */
-const selectAnalysisLanguage = (state: AnalysisState) => state.analysisLanguage;
+export const selectAnalysisLanguage = (state: AnalysisState) => state.analysisLanguage;
 
 /**
  * Memoized selector that builds a `Map` from `TokenAnalysis.id` to `TokenAnalysis` for O(1) lookup.
@@ -373,6 +617,26 @@ export function selectApprovedGloss(state: AnalysisState, tokenRef: string): str
   return ta?.gloss?.[lang] ?? '';
 }
 
+const EMPTY_MORPHEMES: readonly MorphemeAnalysis[] = [];
+
+/**
+ * Returns the morpheme array from the approved `TokenAnalysis` for `tokenRef`, or an empty array
+ * when no approved analysis exists or it has no morphemes.
+ *
+ * @param state - The analysis slice state.
+ * @param tokenRef - The `Token.ref` to look up.
+ * @returns The morpheme array, or a stable empty array when absent.
+ */
+export function selectApprovedMorphemes(
+  state: AnalysisState,
+  tokenRef: string,
+): readonly MorphemeAnalysis[] {
+  const approvedId = selectApprovedIdByTokenRef(state).get(tokenRef);
+  if (!approvedId) return EMPTY_MORPHEMES;
+  const ta = selectAnalysisById(state).get(approvedId);
+  return ta?.morphemes ?? EMPTY_MORPHEMES;
+}
+
 /**
  * Projects `phraseAnalysisLinks` out of `AnalysisState` for use as a `createSelector` input.
  *
@@ -394,15 +658,11 @@ export const selectPhraseLinks = createSelector(selectPhraseAnalysisLinksRaw, (l
  * containing it. When a token appears in multiple approved links (data-model violation), the last
  * wins. Recomputes only when approved phrase links change.
  */
-export const selectPhraseLinkByTokenRef = createSelector(selectPhraseLinks, (links) =>
-  links.reduce((map, link) => {
-    link.tokens.reduce((m, snap) => {
-      m.set(snap.tokenRef, link);
-      return m;
-    }, map);
-    return map;
-  }, new Map<string, PhraseAnalysisLink>()),
-);
+export const selectPhraseLinkByTokenRef = createSelector(selectPhraseLinks, (links) => {
+  const map = new Map<string, PhraseAnalysisLink>();
+  links.forEach((link) => link.tokens.forEach((snap) => map.set(snap.tokenRef, link)));
+  return map;
+});
 
 /**
  * Memoized selector that builds a `Map` from `analysisId` to approved `PhraseAnalysisLink` for O(1)
diff --git a/src/types/interlinearizer.d.ts b/src/types/interlinearizer.d.ts
index 93c2b967..9a490996 100644
--- a/src/types/interlinearizer.d.ts
+++ b/src/types/interlinearizer.d.ts
@@ -29,6 +29,11 @@ declare module 'papi-shared-types' {
      * each chapter is labeled `chapter:verse` instead of a bare verse number.
      */
     'interlinearizer.chapterLabelInVerse': boolean;
+    /**
+     * When true, each word token displays its morpheme breakdown and per-morpheme glosses beneath
+     * the token-level gloss input.
+     */
+    'interlinearizer.showMorphology': boolean;
   }
 
   /**
@@ -845,6 +850,13 @@ declare module 'interlinearizer' {
      * exposure — see `GrammarRef`). Absent when MSA-level detail is not available.
      */
     grammarRef?: GrammarRef;
+
+    /**
+     * Free-form gloss string keyed by BCP 47 analysis-language tag. Analogous to
+     * `TokenAnalysis.gloss` but scoped to a single morpheme. Takes precedence over any gloss
+     * resolved through `senseRef` when both are present.
+     */
+    gloss?: MultiString;
   }
 
   // ---------------------------------------------------------------------------
diff --git a/src/types/type-guards.ts b/src/types/type-guards.ts
index 030826b7..59b3a350 100644
--- a/src/types/type-guards.ts
+++ b/src/types/type-guards.ts
@@ -75,8 +75,9 @@ function isTokenSnapshot(v: unknown): boolean {
 }
 
 /**
- * Checks that `v` satisfies the base `Analysis` shape (`id` and `surfaceText`). Used as the
- * `.every()` predicate for `segmentAnalyses`, `tokenAnalyses`, and `phraseAnalyses`.
+ * Checks that `v` satisfies the base `Analysis` shape (`id` and `surfaceText`). Used directly as
+ * the `.every()` predicate for `segmentAnalyses` and `phraseAnalyses`, and as the base of
+ * {@link isTokenAnalysisRecord} for `tokenAnalyses`.
  *
  * @param v - The value to test.
  * @returns `true` if `v` is an object with string `id` and `surfaceText` properties.
@@ -92,6 +93,45 @@ function isAnalysisRecord(v: unknown): boolean {
   );
 }
 
+/**
+ * Checks that `v` has the required fields of a `MorphemeAnalysis` (`id`, `form`, `writingSystem`).
+ * Used to validate the elements of a `TokenAnalysis.morphemes` array at the persistence boundary.
+ *
+ * @param v - The value to test.
+ * @returns `true` if `v` is an object with string `id`, `form`, and `writingSystem` properties.
+ */
+function isMorphemeAnalysis(v: unknown): boolean {
+  return (
+    !!v &&
+    typeof v === 'object' &&
+    'id' in v &&
+    typeof v.id === 'string' &&
+    'form' in v &&
+    typeof v.form === 'string' &&
+    'writingSystem' in v &&
+    typeof v.writingSystem === 'string'
+  );
+}
+
+/**
+ * Checks that `v` satisfies the `TokenAnalysis` shape: the base `Analysis` fields plus, when
+ * present, a `morphemes` array whose every element passes {@link isMorphemeAnalysis}. Morphemes are
+ * first-class data read by the UI (`m.id` keys, `m.form`, `m.writingSystem`), so a malformed array
+ * must be rejected before persisting rather than surfacing as a render-time fault.
+ *
+ * @param v - The value to test.
+ * @returns `true` if `v` is a valid analysis record with a well-formed (or absent) `morphemes`
+ *   array.
+ */
+function isTokenAnalysisRecord(v: unknown): boolean {
+  return (
+    isAnalysisRecord(v) &&
+    !!v &&
+    typeof v === 'object' &&
+    (!('morphemes' in v) || (Array.isArray(v.morphemes) && v.morphemes.every(isMorphemeAnalysis)))
+  );
+}
+
 /**
  * Checks that `v` satisfies the base `AnalysisLink` shape (`analysisId` and a valid `status`). Used
  * as a building block by the three link-specific guards.
@@ -181,7 +221,7 @@ export function isTextAnalysis(value: unknown): value is TextAnalysis {
     value.segmentAnalysisLinks.every(isSegmentAnalysisLink) &&
     'tokenAnalyses' in value &&
     Array.isArray(value.tokenAnalyses) &&
-    value.tokenAnalyses.every(isAnalysisRecord) &&
+    value.tokenAnalyses.every(isTokenAnalysisRecord) &&
     'tokenAnalysisLinks' in value &&
     Array.isArray(value.tokenAnalysisLinks) &&
     value.tokenAnalysisLinks.every(isTokenAnalysisLink) &&
diff --git a/src/types/view-options.ts b/src/types/view-options.ts
new file mode 100644
index 00000000..483a4c0a
--- /dev/null
+++ b/src/types/view-options.ts
@@ -0,0 +1,20 @@
+/**
+ * Bundled display toggles threaded from {@link InterlinearizerLoader} down through the segment and
+ * continuous views to the phrase strips. Grouping them in one object lets intermediate components
+ * forward `viewOptions` unchanged, so adding a new toggle only touches the loader that builds it
+ * and the leaf that reads it — not every component in between.
+ */
+export type ViewOptions = Readonly<{
+  /** When true, link buttons between phrases are hidden in segments other than the active verse. */
+  hideInactiveLinkButtons: boolean;
+  /** When true, phrase-level controls are hidden on every phrase except the focused one. */
+  simplifyPhrases: boolean;
+  /**
+   * When true, every verse is labeled `chapter:verse` and no inline chapter header is shown; when
+   * false, an inline chapter header precedes the first verse of each chapter and verse labels stay
+   * bare verse numbers.
+   */
+  chapterLabelInVerse: boolean;
+  /** When true, morpheme rows and per-morpheme glosses are shown beneath each word token. */
+  showMorphology: boolean;
+}>;