diff --git a/.gitignore b/.gitignore
index 0b7d3321a..99d3b8c5c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -8,3 +8,4 @@ coverage/
 yarn-error.log
 .idea
 Brewfile.lock.json
+.env
diff --git a/src/app/components/book-selector/after-form-submit.ts b/src/app/components/book-selector/after-form-submit.ts
index bc57912e6..8fe0d1e25 100644
--- a/src/app/components/book-selector/after-form-submit.ts
+++ b/src/app/components/book-selector/after-form-submit.ts
@@ -2,6 +2,7 @@ import React from 'react';
 import fetchBooks from '~/models/books';
 import {filterLiveBooks, SalesforceBook} from '~/helpers/books';
 import {useNavigate, NavigateFunction, useLocation} from 'react-router-dom';
+import {captureEvent} from '~/helpers/posthog';
 
 function afterFormSubmit(
     navigate: NavigateFunction,
@@ -17,6 +18,7 @@ function afterFormSubmit(
         /* Send to Tech Scout with books pre-selected -- Language removed */
         const scoutBooks = selectedBooks.map((sfBook) => sfBook.value.replace(/ *\[.*/, ''));
 
+        captureEvent('interest_form_submitted', {bookCount: selectedBooks.length});
         navigate('/partners', {
             state: {
                 confirmation: true,
diff --git a/src/app/components/book-selector/book-selector.tsx b/src/app/components/book-selector/book-selector.tsx
index ce57dc998..7c13a7baa 100644
--- a/src/app/components/book-selector/book-selector.tsx
+++ b/src/app/components/book-selector/book-selector.tsx
@@ -6,6 +6,7 @@ import {salesforceTitles, SalesforceBook} from '~/helpers/books';
 import BookCheckbox from '~/components/book-checkbox/book-checkbox';
 import {useIntl} from 'react-intl';
 import {useFirstSearchArgument} from './after-form-submit';
+import {captureEvent} from '~/helpers/posthog';
 import './book-selector.scss';
 
 const spanishPairings: Record<string, string> = {
@@ -252,6 +253,15 @@ function BookSelector({
 }: {
     data: {books: Books};
 } & PropsFromOutside) {
+    const trackedToggleBook = useCallback(
+        (book: SalesforceBook) => {
+            const action = selectedBooks.includes(book) ? 'deselected' : 'selected';
+
+            captureEvent('book_selected', {bookTitle: book.text, action});
+            toggleBook(book);
+        },
+        [selectedBooks, toggleBook]
+    );
     const books = React.useMemo(
         () => salesforceTitles(data.books).filter(includeFilter),
         [data.books, includeFilter]
@@ -323,7 +333,7 @@ function BookSelector({
                             <SelectedTag
                                 key={book.value}
                                 book={book}
-                                onRemove={toggleBook}
+                                onRemove={trackedToggleBook}
                             />
                         ))}
                     </div>
@@ -340,7 +350,7 @@ function BookSelector({
                         getBooks={booksBySubject}
                         name={name}
                         selectedBooks={selectedBooks}
-                        toggleBook={toggleBook}
+                        toggleBook={trackedToggleBook}
                         limitReached={limitReached}
                         forceOpen={searchLower.length > 0}
                     />
diff --git a/src/app/components/search-bar/search-bar.tsx b/src/app/components/search-bar/search-bar.tsx
index 876239945..030e06a34 100644
--- a/src/app/components/search-bar/search-bar.tsx
+++ b/src/app/components/search-bar/search-bar.tsx
@@ -8,6 +8,7 @@ import {faTimes} from '@fortawesome/free-solid-svg-icons/faTimes';
 import {faSearch} from '@fortawesome/free-solid-svg-icons/faSearch';
 import {treatSpaceOrEnterAsClick} from '~/helpers/events';
 import cn from 'classnames';
+import {captureEvent} from '~/helpers/posthog';
 import './search-bar.scss';
 
 type SearchBarParams = {
@@ -51,10 +52,11 @@ function SearchInput({amongWhat}: Pick<SearchBarParams, 'amongWhat'>) {
         (event: React.KeyboardEvent) => {
             if (event.key === 'Enter') {
                 event.preventDefault();
+                captureEvent('book_search_performed', {searchQuery: searchString});
                 doSearch();
             }
         },
-        [doSearch]
+        [doSearch, searchString]
     );
     const inputId = `search-${amongWhat}`;
 
@@ -119,13 +121,17 @@ function ClearButton() {
 }
 
 function SearchButton() {
-    const {doSearch} = useSearchContext();
+    const {doSearch, searchString} = useSearchContext();
+    const handleSearch = React.useCallback(() => {
+        captureEvent('book_search_performed', {searchQuery: searchString});
+        doSearch();
+    }, [doSearch, searchString]);
 
     return (
         <button
             className="btn primary"
             type="button"
-            onClick={doSearch}
+            onClick={handleSearch}
             aria-label="search"
         >
             <FontAwesomeIcon icon={faSearch} />
diff --git a/src/app/components/shell/shell.tsx b/src/app/components/shell/shell.tsx
index 81026b310..0e5d3ef09 100644
--- a/src/app/components/shell/shell.tsx
+++ b/src/app/components/shell/shell.tsx
@@ -1,20 +1,50 @@
 import React from 'react';
 import {LanguageContextProvider} from '~/contexts/language';
 import {SubjectCategoryContextProvider} from '~/contexts/subject-category';
-import {UserContextProvider} from '~/contexts/user';
+import useUserContext, {UserContextProvider, UserStatus} from '~/contexts/user';
 import {BrowserRouter, Routes, Route} from 'react-router-dom';
 import {SharedDataContextProvider} from '../../contexts/shared-data';
 import JITLoad from '~/helpers/jit-load';
 import {SalesforceContextProvider} from '~/contexts/salesforce';
 import {PortalContextProvider} from '~/contexts/portal';
 import HeadlessUserbar from '~/components/headless-userbar/headless-userbar';
+import {identifyUser, resetUser} from '~/helpers/posthog';
 
 import Error404 from '~/pages/404/404';
 
+function identifyProps(userStatus: UserStatus | undefined) {
+    return {
+        isInstructor: Boolean(userStatus?.isInstructor),
+        isStudent: Boolean(userStatus?.isStudent),
+        school: userStatus?.school
+    };
+}
+
+/** PostHog is loaded by GTM, so there's no SDK to init here — just tell it
+ *  who's logged in once the user model resolves, and clear on logout. */
+function PostHogUserIdentifier() {
+    const {uuid, userStatus} = useUserContext();
+    const prevUuidRef = React.useRef<string | undefined>(undefined);
+
+    React.useEffect(() => {
+        const prevUuid = prevUuidRef.current;
+
+        prevUuidRef.current = uuid;
+        if (uuid && uuid !== prevUuid) {
+            identifyUser(uuid, identifyProps(userStatus));
+        } else if (!uuid && prevUuid) {
+            resetUser();
+        }
+    }, [uuid, userStatus]);
+
+    return null;
+}
+
 function AppContext({children}: React.PropsWithChildren<object>) {
     return (
         <SharedDataContextProvider>
             <UserContextProvider>
+                <PostHogUserIdentifier />
                 <LanguageContextProvider>
                     <PortalContextProvider>
                         <SubjectCategoryContextProvider>
diff --git a/src/app/contexts/shared-data.ts b/src/app/contexts/shared-data.ts
index c1a0a3935..cb4463470 100644
--- a/src/app/contexts/shared-data.ts
+++ b/src/app/contexts/shared-data.ts
@@ -1,11 +1,14 @@
+import React from 'react';
 import buildContext from '~/components/jsx-helpers/build-context';
 import cmsFetch from '~/helpers/cms-fetch';
 import {usePromise} from '~/helpers/use-data';
+import {registerProperties} from '~/helpers/posthog';
 
 type FlagName =
     | 'myox_pardot'
     | 'my_openstax'
     | 'new_subjects'
+    | 'streamlined_nav'
     | 'chat_book_details'
     | 'chat_subjects'
     | 'chat_contact'
@@ -31,6 +34,15 @@ function useFlags() {
 function useContextValue() {
     const flags = useFlags();
 
+    // Tag every subsequent PostHog event with the streamlined_nav cohort, so
+    // its effect on any existing funnel can be measured without new events.
+    React.useEffect(() => {
+        if (flags) {
+            /* eslint-disable-next-line camelcase */
+            registerProperties({streamlined_nav: Boolean(flags.streamlined_nav)});
+        }
+    }, [flags]);
+
     return {
         flags
     } as const;
diff --git a/src/app/helpers/posthog.ts b/src/app/helpers/posthog.ts
new file mode 100644
index 000000000..5717f45bc
--- /dev/null
+++ b/src/app/helpers/posthog.ts
@@ -0,0 +1,78 @@
+import React from 'react';
+
+export type FlagValue = string | boolean | undefined;
+
+type PostHogClient = {
+    getFeatureFlag: (key: string) => FlagValue;
+    onFeatureFlags: (cb: () => void) => void;
+    capture: (event: string, properties?: Record<string, unknown>) => void;
+    identify: (uuid: string, properties?: Record<string, unknown>) => void;
+    reset: () => void;
+    register: (properties: Record<string, unknown>) => void;
+};
+
+/** PostHog is loaded by GTM; it may not be present yet (pre-consent). */
+function getPostHog(): PostHogClient | undefined {
+    return (window as unknown as {posthog?: PostHogClient}).posthog;
+}
+
+/** Read an experiment/feature-flag variant. Reading it auto-fires the
+ *  `$feature_flag_called` exposure event in PostHog. */
+export function getExperimentVariant(flagKey: string): FlagValue {
+    return getPostHog()?.getFeatureFlag(flagKey);
+}
+
+/** Fire a goal/auxiliary event. Safe no-op when PostHog is absent. */
+export function captureEvent(event: string, properties?: Record<string, unknown>) {
+    getPostHog()?.capture(event, properties);
+}
+
+/** Identify the logged-in user so events/session replay attach to their uuid. */
+export function identifyUser(uuid: string, properties?: Record<string, unknown>) {
+    getPostHog()?.identify(uuid, properties);
+}
+
+/** Clear identity on logout. */
+export function resetUser() {
+    getPostHog()?.reset();
+}
+
+/** Attach a property (e.g. a CMS flag cohort) to every event captured from
+ *  here on, so any funnel/insight can be sliced by it without new events. */
+export function registerProperties(properties: Record<string, unknown>) {
+    getPostHog()?.register(properties);
+}
+
+/** Subscribe to PostHog flag resolution and return a synchronous variant
+ *  reader. Re-renders the caller once flags load, so callers can read any
+ *  number of flags (e.g. while filtering a list) without breaking hooks rules. */
+export function useExperimentReader(): (flag: string) => FlagValue {
+    const [, forceRender] = React.useReducer((n: number) => n + 1, 0);
+
+    React.useEffect(() => {
+        let interval: number | undefined;
+
+        const subscribe = () => {
+            const ph = getPostHog();
+
+            if (!ph) {
+                return false;
+            }
+            ph.onFeatureFlags(() => forceRender());
+            return true;
+        };
+
+        if (!subscribe()) {
+            interval = window.setInterval(() => {
+                if (subscribe()) {
+                    window.clearInterval(interval);
+                }
+            }, 250);
+        }
+
+        return () => {
+            window.clearInterval(interval);
+        };
+    }, []);
+    return getExperimentVariant;
+}
diff --git a/src/app/layouts/default/header/menus/main-menu/main-menu.tsx b/src/app/layouts/default/header/menus/main-menu/main-menu.tsx
index 7b056878c..9d31926b1 100644
--- a/src/app/layouts/default/header/menus/main-menu/main-menu.tsx
+++ b/src/app/layouts/default/header/menus/main-menu/main-menu.tsx
@@ -8,6 +8,12 @@ import {
 import {FormattedMessage} from 'react-intl';
 import {useLocation} from 'react-router-dom';
 import {useDataFromSlug} from '~/helpers/page-data-utils';
+import {useExperimentReader, type FlagValue} from '~/helpers/posthog';
+import {
+    NAV_PRODUCTS_LABEL_FLAG,
+    isNodeVisible,
+    dropdownLabel
+} from './nav-experiments';
 import Dropdown, {MenuItem} from './dropdown/dropdown';
 import LoginMenu from './login-menu/login-menu';
 import GiveItem from '../give-item/give-item';
@@ -18,24 +24,38 @@ type MenuItemData =
     | {
           name: string;
           menu: MenuItemData[];
+          key?: string;
+          feature_flag?: string;
+          flag_value?: string;
       }
     | {
           label: string;
           partial_url: string;
+          key?: string;
+          feature_flag?: string;
+          flag_value?: string;
       }
     | object;
 
-function DropdownOrMenuItem({item}: {item: MenuItemData}) {
+function DropdownOrMenuItem({
+    item,
+    getVariant
+}: {
+    item: MenuItemData;
+    getVariant: (flag: string) => FlagValue;
+}) {
     if (!('name' in item) && !('label' in item)) {
         return null;
     }
+    if (!isNodeVisible(item, getVariant)) {
+        return null;
+    }
     if ('menu' in item) {
+        const label = dropdownLabel(item, getVariant(NAV_PRODUCTS_LABEL_FLAG));
+
         return (
-            <Dropdown
-                label={item.name!}
-                navAnalytics={`Main Menu (${item.name})`}
-            >
-                <MenusFromStructure structure={item.menu} />
+            <Dropdown label={label} navAnalytics={`Main Menu (${item.name})`}>
+                <MenusFromStructure structure={item.menu} getVariant={getVariant} />
             </Dropdown>
         );
     }
@@ -43,13 +63,33 @@ function DropdownOrMenuItem({item}: {item: MenuItemData}) {
     return <MenuItem label={item.label} url={item.partial_url} />;
 }
 
-function MenusFromStructure({structure}: {structure: MenuItemData[]}) {
+function stringProp(item: MenuItemData, prop: 'key' | 'partial_url' | 'name'): string | undefined {
+    const value = (item as Record<string, unknown>)[prop];
+
+    return typeof value === 'string' ? value : undefined;
+}
+
+function keyFor(item: MenuItemData, index: number): string | number {
+    return stringProp(item, 'key') ||
+        stringProp(item, 'partial_url') ||
+        stringProp(item, 'name') ||
+        index;
+}
+
+function MenusFromStructure({
+    structure,
+    getVariant
+}: {
+    structure: MenuItemData[];
+    getVariant: (flag: string) => FlagValue;
+}) {
     return (
         <React.Fragment>
             {structure.map((item, index) => (
                 <DropdownOrMenuItem
-                    key={'label' in item ? item.label : index}
+                    key={keyFor(item, index)}
                     item={item}
+                    getVariant={getVariant}
                 />
             ))}
         </React.Fragment>
@@ -57,13 +97,14 @@ function MenusFromStructure({structure}: {structure: MenuItemData[]}) {
 }
 
 function MenusFromCMS() {
+    const getVariant = useExperimentReader();
     const structure = useDataFromSlug('oxmenus') as MenuItemData[] | undefined;
 
     if (!structure) {
         return null;
     }
 
-    return <MenusFromStructure structure={structure} />;
+    return <MenusFromStructure structure={structure} getVariant={getVariant} />;
 }
 
 function K12MenuItem() {
diff --git a/src/app/layouts/default/header/menus/main-menu/nav-experiments.ts b/src/app/layouts/default/header/menus/main-menu/nav-experiments.ts
new file mode 100644
index 000000000..20416ad63
--- /dev/null
+++ b/src/app/layouts/default/header/menus/main-menu/nav-experiments.ts
@@ -0,0 +1,52 @@
+import type {FlagValue} from '~/helpers/posthog';
+
+export const NAV_PRODUCTS_LABEL_FLAG = 'nav-products-label';
+
+/** Stable CMS `key` of the dropdown under the Products/Tools A/B.
+ *  CONFIRM this matches the `key` set on that dropdown in Wagtail. */
+export const PRODUCTS_DROPDOWN_KEY = 'products-dropdown';
+const TOOLS_LABEL = 'Tools';
+
+/** Flag metadata any CMS menu node may carry (snake_case, matching the
+ *  oxmenus API — same casing as `partial_url`). */
+export type FlagAwareNode = {
+    key?: string;
+    feature_flag?: string;
+    flag_value?: string;
+};
+
+/** Generic visibility gate from a node's optional flag metadata.
+ *  - no feature_flag     → always visible
+ *  - flag_value provided → visible iff String(variant) === flag_value
+ *  - flag_value blank    → visible iff the flag is truthy
+ *  Nodes gated ON by a flag appear once PostHog's flags resolve (fine for
+ *  additive items); author controls/defaults WITHOUT a feature_flag so they
+ *  render immediately. */
+export function isNodeVisible(
+    node: FlagAwareNode,
+    getVariant: (flag: string) => FlagValue
+): boolean {
+    const flag = node.feature_flag;
+
+    if (!flag) {
+        return true;
+    }
+    const variant = getVariant(flag);
+
+    if (node.flag_value) {
+        return String(variant) === node.flag_value;
+    }
+    return Boolean(variant);
+}
+
+/** A/B label swap for the Products dropdown, keyed by stable `key`
+ *  (not the display label, so editors can rename freely). */
+export function dropdownLabel(
+    node: {key?: string; name?: string},
+    productsVariant: FlagValue
+): string {
+    if (node.key === PRODUCTS_DROPDOWN_KEY && productsVariant === 'tools') {
+        return TOOLS_LABEL;
+    }
+    return node.name ?? '';
+}
diff --git a/src/app/pages/adoption/adoption.tsx b/src/app/pages/adoption/adoption.tsx
index c0bc2e06c..f4d0cbf8b 100644
--- a/src/app/pages/adoption/adoption.tsx
+++ b/src/app/pages/adoption/adoption.tsx
@@ -2,6 +2,7 @@ import React, {useState, useRef, useCallback} from 'react';
 import {useLocation} from 'react-router-dom';
 import useDocumentHead, {useCanonicalLink} from '~/helpers/use-document-head';
 import FormHeader from '~/components/form-header/form-header';
+import {captureEvent} from '~/helpers/posthog';
 import RoleSelector from '~/components/role-selector/role-selector';
 import StudentForm from '~/components/student-form/student-form';
 import MultiPageForm from '~/components/multi-page-form/multi-page-form';
@@ -215,10 +216,11 @@ function FacultyForm({
 
     const doSubmit = useCallback(
         (form: HTMLFormElement) => {
+            captureEvent('adoption_form_submitted', {bookCount: selectedBooksRef.current.length});
             form.submit();
             onSubmit();
         },
-        [onSubmit]
+        [onSubmit, selectedBooksRef]
     );
 
     const hiddenFields = (
diff --git a/src/app/pages/blog/gated-content-dialog/gated-content-dialog.tsx b/src/app/pages/blog/gated-content-dialog/gated-content-dialog.tsx
index b710723ce..7c56efe78 100644
--- a/src/app/pages/blog/gated-content-dialog/gated-content-dialog.tsx
+++ b/src/app/pages/blog/gated-content-dialog/gated-content-dialog.tsx
@@ -12,6 +12,7 @@ import type {ArticleData} from '../article/article';
 import useBlogContext from '../blog-context';
 import cn from 'classnames';
 import settings from '~/helpers/window-settings';
+import {captureEvent} from '~/helpers/posthog';
 import './gated-content-dialog.scss';
 
 const formSubmitUrl = settings().gatedContentEndpoint;
@@ -24,12 +25,17 @@ function GatedContentDialog() {
     const [Dialog, open, close] = useDialog();
     const {userModel} = useUserContext();
     const [submitted, setSubmitted] = React.useState(false);
+    const hasTrackedRef = React.useRef(false);
 
     React.useEffect(() => {
         if (userModel?.id || submitted) {
             close();
         } else {
             open();
+            if (!hasTrackedRef.current) {
+                captureEvent('gated_content_viewed');
+                hasTrackedRef.current = true;
+            }
         }
     }, [userModel, open, close, submitted]);
 
@@ -107,7 +113,10 @@ function GatedContentForm({
     setSubmitted: React.Dispatch<React.SetStateAction<boolean>>;
 }) {
     const afterSubmit = React.useCallback(
-        () => setSubmitted(true),
+        () => {
+            captureEvent('gated_content_form_submitted');
+            setSubmitted(true);
+        },
         [setSubmitted]
     );
 
diff --git a/src/app/pages/contact/form.tsx b/src/app/pages/contact/form.tsx
index 451f979e8..035421b01 100644
--- a/src/app/pages/contact/form.tsx
+++ b/src/app/pages/contact/form.tsx
@@ -4,6 +4,7 @@ import DropdownSelect from '~/components/select/drop-down/drop-down';
 import {useNavigate, useLocation} from 'react-router-dom';
 import { FileButton } from '../errata-form/form/FileUploader';
 import useUserContext from '~/contexts/user';
+import {captureEvent} from '~/helpers/posthog';
 import './form.scss';
 
 type SetSubmitted = React.Dispatch<React.SetStateAction<boolean>>;
@@ -77,19 +78,20 @@ function useIsEmbedded() {
     return pathname.includes('embedded');
 }
 
-function useAfterSubmit(setSubmitted?: SetSubmitted) {
+function useAfterSubmit(setSubmitted?: SetSubmitted, subject?: string) {
     const navigate = useNavigate();
     const isEmbedded = useIsEmbedded();
 
     return React.useCallback(
         () => {
+            captureEvent('contact_form_submitted', {subject});
             if (isEmbedded) {
                 (setSubmitted as SetSubmitted)(true); // the embedded form passes it
             } else {
                 navigate('/confirmation/contact');
             }
         },
-        [navigate, isEmbedded, setSubmitted]
+        [navigate, isEmbedded, setSubmitted, subject]
     );
 }
 
@@ -140,7 +142,7 @@ export default function ContactForm({setSubmitted}: {setSubmitted?: SetSubmitted
         () => setShowInvalidMessages(true),
         [setShowInvalidMessages]
     );
-    const afterSubmit = useAfterSubmit(setSubmitted);
+    const afterSubmit = useAfterSubmit(setSubmitted, subject);
     const searchParams = new window.URLSearchParams(window.location.search);
     const bodyParams = searchParams.getAll('body').join('\n');
     const {userStatus} = useUserContext();
diff --git a/src/app/pages/details/common/get-this-title-files/give-before-pdf/common-elements.tsx b/src/app/pages/details/common/get-this-title-files/give-before-pdf/common-elements.tsx
index f82ed5bb0..9d083e237 100644
--- a/src/app/pages/details/common/get-this-title-files/give-before-pdf/common-elements.tsx
+++ b/src/app/pages/details/common/get-this-title-files/give-before-pdf/common-elements.tsx
@@ -2,6 +2,7 @@ import React from 'react';
 import {FontAwesomeIcon} from '@fortawesome/react-fontawesome';
 import {faHeart} from '@fortawesome/free-solid-svg-icons/faHeart';
 import {useLocation} from 'react-router-dom';
+import {captureEvent} from '~/helpers/posthog';
 
 type Data = {
     header_subtitle: string;
@@ -26,6 +27,10 @@ export default function CommonElements({
 }) {
     const initialItem = React.useRef<HTMLAnchorElement>(null);
     const {pathname} = useLocation();
+    const handleGiveClick = React.useCallback((event: React.MouseEvent) => {
+        captureEvent('donation_initiated');
+        openGiveInNewWindow(event);
+    }, []);
 
     React.useEffect(() => initialItem.current?.focus(), []);
     return (
@@ -55,7 +60,7 @@ export default function CommonElements({
                 <a
                     href={giveLink}
                     className="btn primary"
-                    onClick={OpenGiveInNewWindow}
+                    onClick={handleGiveClick}
                     data-nudge-action="interacted"
                     ref={initialItem}
                 >
@@ -77,7 +82,7 @@ export default function CommonElements({
     );
 }
 
-function OpenGiveInNewWindow(event: React.MouseEvent) {
+function openGiveInNewWindow(event: React.MouseEvent) {
     event.preventDefault();
     const url = (event.target as HTMLAnchorElement).href;
     const {innerWidth, innerHeight} = window;
diff --git a/src/app/pages/details/common/get-this-title-files/give-before-pdf/give-before-pdf.tsx b/src/app/pages/details/common/get-this-title-files/give-before-pdf/give-before-pdf.tsx
index 8ed54123f..23ea4b200 100644
--- a/src/app/pages/details/common/get-this-title-files/give-before-pdf/give-before-pdf.tsx
+++ b/src/app/pages/details/common/get-this-title-files/give-before-pdf/give-before-pdf.tsx
@@ -4,6 +4,7 @@ import CommonElements from './common-elements';
 import type {DonationPopupData} from './use-donation-popup-data';
 import {enroll} from '@openstax/experiments';
 import useGiveLinks from './use-give-links';
+import {captureEvent} from '~/helpers/posthog';
 import './give-before-pdf.scss';
 
 export default function GiveBeforePdf({
@@ -95,12 +96,13 @@ function GiveBeforePdfAfterConditionals({
 
     const closeAfterDelay = React.useCallback(
         (event: React.MouseEvent) => {
+            captureEvent('pdf_downloaded', {bookFormat: track});
             if (onDownload) {
                 onDownload(event);
             }
             window.setTimeout(close, 200);
         },
-        [close, onDownload]
+        [close, onDownload, track]
     );
 
     return (
diff --git a/src/app/pages/details/common/get-this-title-files/give-before-pdf/thank-you-form.tsx b/src/app/pages/details/common/get-this-title-files/give-before-pdf/thank-you-form.tsx
index e7e59d6dd..75f12bc64 100644
--- a/src/app/pages/details/common/get-this-title-files/give-before-pdf/thank-you-form.tsx
+++ b/src/app/pages/details/common/get-this-title-files/give-before-pdf/thank-you-form.tsx
@@ -3,6 +3,7 @@ import useUserContext from '~/contexts/user';
 import trackLink from '../../track-link';
 import './thank-you-form.scss';
 import SchoolSelector from '~/components/school-selector/school-selector';
+import {captureEvent} from '~/helpers/posthog';
 
 function FormWithAfterSubmit({
     afterSubmit,
@@ -75,6 +76,7 @@ export default function ThankYou({
 }) {
     const {first, last, school, accountUuid} = useUserFields();
     const afterSubmit = React.useCallback(() => {
+        captureEvent('thank_you_note_submitted');
         window.open(link);
         close();
     }, [link, close]);
diff --git a/src/app/pages/details/common/get-this-title-files/options.tsx b/src/app/pages/details/common/get-this-title-files/options.tsx
index e8e536206..de9f81df4 100644
--- a/src/app/pages/details/common/get-this-title-files/options.tsx
+++ b/src/app/pages/details/common/get-this-title-files/options.tsx
@@ -13,6 +13,7 @@ import {treatSpaceOrEnterAsClick} from '~/helpers/events';
 import {useIntl} from 'react-intl';
 import OrderPrintCopy from './order-print-copy/order-print-copy';
 import useTOCContext from '../toc-slideout/context';
+import {captureEvent} from '~/helpers/posthog';
 import {useDialog} from '~/components/dialog/dialog';
 import {useOpenGiveDialog} from './give-before-pdf/use-give-dialog';
 import trackLink from '../track-link';
@@ -82,6 +83,9 @@ export function TocOption({model}: {model: Model}) {
     }
 
     function toggleToc(event: React.MouseEvent) {
+        if (!isOpen) {
+            captureEvent('toc_opened', {bookTitle: model.title});
+        }
         toggle();
         event.preventDefault();
     }
@@ -121,6 +125,13 @@ export function WebviewOption({model}: {model: Model}) {
         },
         [model.id]
     );
+    const handleWebviewClick = React.useCallback(
+        (event: React.MouseEvent) => {
+            captureEvent('book_webview_opened', {bookTitle: model.title});
+            openGiveDialog(event as React.MouseEvent);
+        },
+        [openGiveDialog, model.title]
+    );
 
     return (
         <Option condition={!model.comingSoon && webviewLink}>
@@ -129,7 +140,7 @@ export function WebviewOption({model}: {model: Model}) {
                     href={webviewLink}
                     data-local={isRex}
                     rel="noreferrer"
-                    onClick={openGiveDialog}
+                    onClick={handleWebviewClick}
                 >
                     <IconAndText {...iconAndTextArgs} />
                 </a>
diff --git a/src/app/pages/details/common/get-this-title-files/order-print-copy/order-print-copy.tsx b/src/app/pages/details/common/get-this-title-files/order-print-copy/order-print-copy.tsx
index a15ed227c..a6f99fd3c 100644
--- a/src/app/pages/details/common/get-this-title-files/order-print-copy/order-print-copy.tsx
+++ b/src/app/pages/details/common/get-this-title-files/order-print-copy/order-print-copy.tsx
@@ -7,6 +7,7 @@ import {useIntl} from 'react-intl';
 import './order-print-copy.scss';
 import cmsFetch from '~/helpers/cms-fetch';
 import linkHelper, {type UtmCampaign} from '~/helpers/link';
+import {captureEvent} from '~/helpers/posthog';
 
 type Content = {
     headerText: string;
@@ -29,8 +30,13 @@ function Header({entry}: {entry: Content}) {
 }
 
 function PhoneBox({entry}: {entry: Content}) {
+    const handleClick = React.useCallback(
+        () => captureEvent('print_copy_clicked', {format: entry.trackingLabel}),
+        [entry.trackingLabel]
+    );
+
     return (
-        <a className="box" href={entry.buttonUrl} data-track={entry.trackingLabel}>
+        <a className="box" href={entry.buttonUrl} data-track={entry.trackingLabel} onClick={handleClick}>
             <Header entry={entry} />
         </a>
     );
@@ -57,8 +63,13 @@ function Button({
     buttonClass: string;
     trackingLabel: Content['trackingLabel'];
 }) {
+    const handleClick = React.useCallback(
+        () => captureEvent('print_copy_clicked', {format: trackingLabel}),
+        [trackingLabel]
+    );
+
     return (
-        <a className={`btn ${buttonClass}`} href={href} data-track={trackingLabel}>
+        <a className={`btn ${buttonClass}`} href={href} data-track={trackingLabel} onClick={handleClick}>
             {text}
         </a>
     );
diff --git a/src/app/pages/details/common/resource-box/left-content.tsx b/src/app/pages/details/common/resource-box/left-content.tsx
index 8a916fce3..e9763a74c 100644
--- a/src/app/pages/details/common/resource-box/left-content.tsx
+++ b/src/app/pages/details/common/resource-box/left-content.tsx
@@ -13,6 +13,7 @@ import useGiveDialog, { VariantValue } from '../get-this-title-files/give-before
 import {IconDefinition} from '@fortawesome/fontawesome-svg-core';
 import {TrackedMouseEvent} from '~/components/shell/router-helpers/use-link-handler';
 import {ResourceModel} from './resource-boxes';
+import {captureEvent} from '~/helpers/posthog';
 
 // ResourceModel & LinkIsSet changes link from optional to required.
 type LinkIsSet = {
@@ -112,6 +113,10 @@ function LeftButton({model}: {model: ResourceModel & LinkIsSet}) {
     const ariaLabel = isDownload ? `Download ${model.heading}` : `Go to ${model.heading}`;
 
     function openDialog(event: TrackedMouseEvent) {
+        captureEvent('resource_accessed', {
+            resourceName: model.heading,
+            resourceCategory: model.resourceCategory
+        });
         if (isDownload && enabled) {
             event.preventDefault();
             open();
diff --git a/src/app/pages/errata-form/form/form.tsx b/src/app/pages/errata-form/form/form.tsx
index e29912bbc..df6680c98 100644
--- a/src/app/pages/errata-form/form/form.tsx
+++ b/src/app/pages/errata-form/form/form.tsx
@@ -10,6 +10,7 @@ import $ from '~/helpers/$';
 import Dialog from '~/components/dialog/dialog';
 import {useNavigate} from 'react-router-dom';
 import cn from 'classnames';
+import {captureEvent} from '~/helpers/posthog';
 import './form.scss';
 
 type ApiResponse = {
@@ -149,6 +150,7 @@ function useBannedDialog() {
     const handleSubmissionResponse = React.useCallback(
         (json: ApiResponse) => {
             if (json.id) {
+                captureEvent('errata_submitted');
                 navigate(`/confirmation/errata?id=${json.id}`);
             } else if (json.submitted_by_account_id) {
                 setBannedText(json.submitted_by_account_id[0]);
diff --git a/src/app/pages/partners/partner-details/info-request-form/info-request-form.tsx b/src/app/pages/partners/partner-details/info-request-form/info-request-form.tsx
index 7cede4d2b..25f0344c2 100644
--- a/src/app/pages/partners/partner-details/info-request-form/info-request-form.tsx
+++ b/src/app/pages/partners/partner-details/info-request-form/info-request-form.tsx
@@ -1,5 +1,6 @@
 import React from 'react';
 import usePartnerContext from '../partner-context';
+import {captureEvent} from '~/helpers/posthog';
 import {useDataFromSlug} from '~/helpers/page-data-utils';
 import useUserContext from '~/contexts/user';
 import MultiPageForm from '~/components/multi-page-form/multi-page-form';
@@ -217,8 +218,12 @@ function Page2() {
 }
 
 export default function InfoRequestForm() {
-    const {toggleForm} = usePartnerContext();
-    const {onSubmit, submitting, FormTarget} = useFormTarget(toggleForm);
+    const {toggleForm, partnerName} = usePartnerContext() as {toggleForm: () => void; partnerName: string};
+    const afterSubmit = React.useCallback(() => {
+        captureEvent('partner_info_requested', {partnerName});
+        toggleForm();
+    }, [toggleForm, partnerName]);
+    const {onSubmit, submitting, FormTarget} = useFormTarget(afterSubmit);
     const {techScoutUrl} = useSalesforceContextValue();
     const doSubmit = useDoSubmit(onSubmit);
 
diff --git a/src/app/pages/partners/results/result-grid.tsx b/src/app/pages/partners/results/result-grid.tsx
index c4668edc7..8e1f5fe72 100644
--- a/src/app/pages/partners/results/result-grid.tsx
+++ b/src/app/pages/partners/results/result-grid.tsx
@@ -2,6 +2,7 @@ import React from 'react';
 import {useNavigate} from 'react-router-dom';
 import type {PartnerEntry} from './results';
 import PartnerCard from '~/components/partner-card/partner-card';
+import {captureEvent} from '~/helpers/posthog';
 
 export const badgeImage = '/dist/images/partners/verified-badge.svg';
 export function useOnSelect() {
@@ -21,6 +22,13 @@ export function useOnSelect() {
 function ResultCard({entry}: {entry: PartnerEntry}) {
     const {type, title, logoUrl, tags} = entry;
     const onSelect = useOnSelect();
+    const handleClick = React.useCallback(
+        (event: React.MouseEvent<HTMLAnchorElement>) => {
+            captureEvent('partner_card_clicked', {partnerName: title, partnerType: type});
+            onSelect(event);
+        },
+        [onSelect, title, type]
+    );
 
     return (
         <PartnerCard
@@ -29,7 +37,7 @@ function ResultCard({entry}: {entry: PartnerEntry}) {
             title={title}
             logoUrl={logoUrl}
             tags={tags.map((t) => t.value).filter((v) => v !== null)}
-            onClick={onSelect}
+            onClick={handleClick}
             badgeImage={badgeImage}
             analyticsContentType="Partner Profile"
         />
diff --git a/test/src/components/search-bar.test.tsx b/test/src/components/search-bar.test.tsx
index ecff6fdaa..8a5f79088 100644
--- a/test/src/components/search-bar.test.tsx
+++ b/test/src/components/search-bar.test.tsx
@@ -42,4 +42,11 @@ describe('search-bar', () => {
         fireEvent.click(clear as HTMLButtonElement);
         expect(input.value).toBe('');
     });
+    it('handles search button click', () => {
+        const searchButton = screen.getAllByRole('button').find((el) => el.getAttribute('aria-label') === 'search');
+
+        fireEvent.input(input, {target: {value: 'biology'}});
+        fireEvent.click(searchButton as HTMLButtonElement);
+        expect(searchFor).toHaveBeenCalled();
+    });
 });
diff --git a/test/src/components/shell.test.tsx b/test/src/components/shell.test.tsx
index f2b0e6438..c994a1605 100644
--- a/test/src/components/shell.test.tsx
+++ b/test/src/components/shell.test.tsx
@@ -16,6 +16,7 @@ import * as LSN from '~/layouts/default/lower-sticky-note/lower-sticky-note';
 import * as DH from '~/helpers/use-document-head';
 import * as UC from '~/contexts/user';
 import * as TM from '~/helpers/tag-manager';
+import * as PH from '~/helpers/posthog';
 import {camelCaseKeys, transformData} from '~/helpers/page-data-utils';
 import landingPage from '../data/landing-page';
 import contactPage from '../data/contact-page';
@@ -369,4 +370,48 @@ describe('shell', () => {
         // Portal should be cleared for non-portal pages
         expect(mockSetPortal).toHaveBeenCalledWith('');
     });
+
+    it('identifies the user in PostHog once uuid resolves', async () => {
+        mockBrowserInitialEntries(['/']);
+        jest.spyOn(UC, 'default').mockReturnValue({
+            uuid: 'user-1',
+            userStatus: {isInstructor: true, isStudent: false, school: 'Rice University'}
+        } as any); // eslint-disable-line @typescript-eslint/no-explicit-any
+        const spyIdentify = jest.spyOn(PH, 'identifyUser').mockImplementation(() => undefined);
+
+        render(AppElement);
+
+        await waitFor(() => expect(spyIdentify).toHaveBeenCalledWith(
+            'user-1',
+            {isInstructor: true, isStudent: false, school: 'Rice University'}
+        ));
+
+        spyIdentify.mockRestore();
+        jest.spyOn(UC, 'default').mockReturnValue({} as any); // eslint-disable-line @typescript-eslint/no-explicit-any
+    });
+
+    it('resets PostHog identity on logout', async () => {
+        mockBrowserInitialEntries(['/']);
+        jest.spyOn(UC, 'default').mockReturnValue({
+            uuid: 'user-1',
+            userStatus: {isInstructor: true}
+        } as any); // eslint-disable-line @typescript-eslint/no-explicit-any
+        const spyReset = jest.spyOn(PH, 'resetUser').mockImplementation(() => undefined);
+
+        const {rerender} = render(AppElement);
+        await screen.findByRole('link', {name: 'skip to main content'});
+
+        jest.spyOn(UC, 'default').mockReturnValue({
+            uuid: undefined,
+            userStatus: undefined
+        } as any); // eslint-disable-line @typescript-eslint/no-explicit-any
+        // A fresh element (not the same reference as AppElement) forces preact
+        // to actually re-render the tree instead of bailing out on identity.
+        rerender(React.createElement(AppElement.type));
+
+        await waitFor(() => expect(spyReset).toHaveBeenCalled());
+
+        spyReset.mockRestore();
+        jest.spyOn(UC, 'default').mockReturnValue({} as any); // eslint-disable-line @typescript-eslint/no-explicit-any
+    });
 });
diff --git a/test/src/helpers/posthog.test.tsx b/test/src/helpers/posthog.test.tsx
new file mode 100644
index 000000000..a66c3ebd7
--- /dev/null
+++ b/test/src/helpers/posthog.test.tsx
@@ -0,0 +1,145 @@
+import React from 'react';
+import {render, screen, act} from '@testing-library/preact';
+import {
+    getExperimentVariant,
+    captureEvent,
+    identifyUser,
+    resetUser,
+    registerProperties,
+    useExperimentReader
+} from '~/helpers/posthog';
+
+type FakePostHog = {
+    getFeatureFlag: jest.Mock;
+    onFeatureFlags: jest.Mock;
+    capture: jest.Mock;
+    identify: jest.Mock;
+    reset: jest.Mock;
+    register: jest.Mock;
+};
+
+function installPostHog(overrides: Partial<FakePostHog> = {}) {
+    const ph: FakePostHog = {
+        getFeatureFlag: jest.fn(),
+        onFeatureFlags: jest.fn(),
+        capture: jest.fn(),
+        identify: jest.fn(),
+        reset: jest.fn(),
+        register: jest.fn(),
+        ...overrides
+    };
+    (window as unknown as {posthog?: FakePostHog}).posthog = ph;
+    return ph;
+}
+
+afterEach(() => {
+    delete (window as unknown as {posthog?: unknown}).posthog;
+});
+
+describe('posthog helper', () => {
+    it('getExperimentVariant returns undefined when posthog is absent', () => {
+        expect(getExperimentVariant('nav-products-label')).toBeUndefined();
+    });
+
+    it('getExperimentVariant reads the flag', () => {
+        installPostHog({getFeatureFlag: jest.fn().mockReturnValue('tools')});
+        expect(getExperimentVariant('nav-products-label')).toBe('tools');
+    });
+
+    it('captureEvent no-ops without posthog', () => {
+        expect(() => captureEvent('thing_clicked')).not.toThrow();
+    });
+
+    it('captureEvent forwards to posthog', () => {
+        const ph = installPostHog();
+        captureEvent('thing_clicked', {a: 1});
+        expect(ph.capture).toHaveBeenCalledWith('thing_clicked', {a: 1});
+    });
+
+    it('identifyUser no-ops without posthog', () => {
+        expect(() => identifyUser('uuid-1')).not.toThrow();
+    });
+
+    it('identifyUser forwards to posthog', () => {
+        const ph = installPostHog();
+        identifyUser('uuid-1', {isInstructor: true});
+        expect(ph.identify).toHaveBeenCalledWith('uuid-1', {isInstructor: true});
+    });
+
+    it('resetUser no-ops without posthog', () => {
+        expect(() => resetUser()).not.toThrow();
+    });
+
+    it('resetUser forwards to posthog', () => {
+        const ph = installPostHog();
+        resetUser();
+        expect(ph.reset).toHaveBeenCalled();
+    });
+
+    it('registerProperties no-ops without posthog', () => {
+        expect(() => registerProperties({streamlined_nav: true})).not.toThrow();
+    });
+
+    it('registerProperties forwards to posthog', () => {
+        const ph = installPostHog();
+        registerProperties({streamlined_nav: true});
+        expect(ph.register).toHaveBeenCalledWith({streamlined_nav: true});
+    });
+});
+
+describe('useExperimentReader', () => {
+    it('returns a reader and re-renders when flags resolve', async () => {
+        const ph = {
+            getFeatureFlag: jest.fn().mockReturnValueOnce(undefined).mockReturnValue('on'),
+            onFeatureFlags: jest.fn(),
+            capture: jest.fn()
+        };
+        (window as unknown as {posthog?: typeof ph}).posthog = ph;
+
+        function Probe() {
+            const getVariant = useExperimentReader();
+            return <span>{String(getVariant('f'))}</span>;
+        }
+        const {findByText, getByText} = render(<Probe />);
+        getByText('undefined');
+        const cb = ph.onFeatureFlags.mock.calls[0][0] as () => void;
+        act(() => cb());
+        await findByText('on');
+        delete (window as unknown as {posthog?: unknown}).posthog;
+    });
+
+    it('polls until PostHog loads (pre-consent), then subscribes and stops polling', () => {
+        jest.useFakeTimers();
+
+        function Probe() {
+            useExperimentReader();
+            return null;
+        }
+        render(<Probe />);
+
+        const ph = installPostHog();
+
+        act(() => jest.advanceTimersByTime(250));
+        expect(ph.onFeatureFlags).toHaveBeenCalledTimes(1);
+
+        act(() => jest.advanceTimersByTime(1000));
+        expect(ph.onFeatureFlags).toHaveBeenCalledTimes(1);
+
+        jest.useRealTimers();
+    });
+
+    it('keeps polling when PostHog is still unavailable', () => {
+        jest.useFakeTimers();
+
+        function Probe() {
+            useExperimentReader();
+            return null;
+        }
+        render(<Probe />);
+
+        act(() => jest.advanceTimersByTime(500));
+        expect((window as unknown as {posthog?: unknown}).posthog).toBeUndefined();
+
+        jest.useRealTimers();
+    });
+});
diff --git a/test/src/layouts/default/header/main-menu-resolver.test.tsx b/test/src/layouts/default/header/main-menu-resolver.test.tsx
new file mode 100644
index 000000000..405d1cbee
--- /dev/null
+++ b/test/src/layouts/default/header/main-menu-resolver.test.tsx
@@ -0,0 +1,115 @@
+import React from 'react';
+import {render, screen, act} from '@testing-library/preact';
+import ShellContextProvider from '../../../../helpers/shell-context';
+import MemoryRouter from '../../../../helpers/future-memory-router';
+import {MainMenuItems} from '~/layouts/default/header/menus/main-menu/main-menu';
+import {useDataFromSlug} from '~/helpers/page-data-utils';
+
+jest.mock('~/models/give-today', () => jest.fn().mockReturnValue({}));
+
+// Mock page-data-utils so we can control what useDataFromSlug('oxmenus') returns.
+// We spread requireActual so everything else (fetchFromCMS, etc.) still works.
+jest.mock('~/helpers/page-data-utils', () => ({
+    ...jest.requireActual('~/helpers/page-data-utils'),
+    useDataFromSlug: jest.fn()
+}));
+
+/* eslint-disable camelcase */
+
+type FakePostHog = {
+    getFeatureFlag: jest.Mock;
+    onFeatureFlags: jest.Mock;
+    capture: jest.Mock;
+    register: jest.Mock;
+};
+
+function installPostHog(overrides: Partial<FakePostHog> = {}) {
+    const ph: FakePostHog = {
+        getFeatureFlag: jest.fn().mockReturnValue(undefined),
+        onFeatureFlags: jest.fn(),
+        capture: jest.fn(),
+        register: jest.fn(),
+        ...overrides
+    };
+    (window as unknown as {posthog?: FakePostHog}).posthog = ph;
+    return ph;
+}
+
+afterEach(() => {
+    delete (window as unknown as {posthog?: unknown}).posthog;
+    (useDataFromSlug as jest.Mock).mockReset();
+});
+
+function Component() {
+    return (
+        <ShellContextProvider>
+            <MemoryRouter initialEntries={['/']}>
+                <ul>
+                    <MainMenuItems />
+                </ul>
+            </MemoryRouter>
+        </ShellContextProvider>
+    );
+}
+
+const cmsMenuWithFlaggedItem = [
+    {
+        name: 'Products',
+        key: 'products-dropdown',
+        menu: [
+            {
+                label: 'Example Item',
+                partial_url: '/example',
+                feature_flag: 'nav-example-item'
+            }
+        ]
+    }
+];
+
+describe('MainMenuItems — generic flag resolver', () => {
+    it('hides a flag-gated CMS menu item when flag is falsy', async () => {
+        installPostHog({
+            getFeatureFlag: jest.fn().mockReturnValue(undefined)
+        });
+        (useDataFromSlug as jest.Mock).mockReturnValue(cmsMenuWithFlaggedItem);
+
+        render(<Component />);
+
+        // Wait for SubjectsMenu to appear
+        await screen.findByText('Subjects');
+
+        // The flag-gated item in the Products dropdown should be hidden
+        expect(screen.queryByRole('link', {name: 'Example Item'})).toBeNull();
+    });
+
+    it('shows a flag-gated CMS menu item when flag becomes truthy', async () => {
+        let flagsLoaded = false;
+        const ph = installPostHog({
+            getFeatureFlag: jest.fn((flag: string) => {
+                if (!flagsLoaded) {
+                    return undefined;
+                }
+                if (flag === 'nav-example-item') {
+                    return true;
+                }
+                return undefined;
+            })
+        });
+        (useDataFromSlug as jest.Mock).mockReturnValue(cmsMenuWithFlaggedItem);
+
+        render(<Component />);
+        await screen.findByText('Subjects');
+
+        // Before flags load, the item is hidden
+        expect(screen.queryByRole('link', {name: 'Example Item'})).toBeNull();
+
+        // Simulate PostHog flags resolving — triggers forceRender in useExperimentReader
+        flagsLoaded = true;
+        const allCbs = ph.onFeatureFlags.mock.calls.map(
+            (call: [() => void]) => call[0]
+        );
+        act(() => allCbs.forEach((cb: () => void) => cb()));
+
+        await screen.findByRole('link', {name: 'Example Item'});
+    });
+});
diff --git a/test/src/layouts/default/header/nav-experiments.test.ts b/test/src/layouts/default/header/nav-experiments.test.ts
new file mode 100644
index 000000000..0b70a6696
--- /dev/null
+++ b/test/src/layouts/default/header/nav-experiments.test.ts
@@ -0,0 +1,35 @@
+import {
+    isNodeVisible,
+    dropdownLabel,
+    PRODUCTS_DROPDOWN_KEY
+} from '~/layouts/default/header/menus/main-menu/nav-experiments';
+
+describe('isNodeVisible', () => {
+    it('is visible with no feature_flag', () => {
+        expect(isNodeVisible({}, () => undefined)).toBe(true);
+    });
+    it('is visible iff the flag is truthy when flag_value is blank', () => {
+        expect(isNodeVisible({feature_flag: 'nav-example-item'}, () => true)).toBe(true);
+        expect(isNodeVisible({feature_flag: 'nav-example-item'}, () => undefined)).toBe(false);
+    });
+    it('matches flag_value as a string', () => {
+        expect(isNodeVisible({feature_flag: 'f', flag_value: 'control'}, () => 'control')).toBe(true);
+        expect(isNodeVisible({feature_flag: 'f', flag_value: 'control'}, () => 'tools')).toBe(false);
+        expect(isNodeVisible({feature_flag: 'f', flag_value: 'false'}, () => false)).toBe(true);
+    });
+});
+
+describe('dropdownLabel', () => {
+    it('keeps the name for non-target dropdowns', () => {
+        expect(dropdownLabel({key: 'subjects', name: 'Subjects'}, 'tools')).toBe('Subjects');
+    });
+    it('keeps the name for the control variant', () => {
+        expect(dropdownLabel({key: PRODUCTS_DROPDOWN_KEY, name: 'Products'}, undefined)).toBe('Products');
+    });
+    it('swaps to Tools for the target key in the tools variant', () => {
+        expect(dropdownLabel({key: PRODUCTS_DROPDOWN_KEY, name: 'Products'}, 'tools')).toBe('Tools');
+    });
+    it('falls back to an empty string when name is missing', () => {
+        expect(dropdownLabel({key: 'subjects'}, undefined)).toBe('');
+    });
+});
diff --git a/test/src/pages/blog/gated-content-dialog.test.tsx b/test/src/pages/blog/gated-content-dialog.test.tsx
index b9dd4e947..27449b88e 100644
--- a/test/src/pages/blog/gated-content-dialog.test.tsx
+++ b/test/src/pages/blog/gated-content-dialog.test.tsx
@@ -8,6 +8,7 @@ import MemoryRouter from '~/../../test/helpers/future-memory-router';
 import GatedContentDialog from '~/pages/blog/gated-content-dialog/gated-content-dialog';
 import type {ArticleData} from '~/pages/blog/article/article';
 import userEvent from '@testing-library/user-event';
+import * as posthog from '~/helpers/posthog';
 
 const articleData: ArticleData = {
     gatedContent: true,
@@ -137,4 +138,18 @@ describe('blog/gated-content-dialog', () => {
         expect(mockClose).not.toHaveBeenCalled();
         mockUseUserContext.mockClear();
     });
+
+    it('tracks gated content view only once', async () => {
+        const captureEventSpy = jest.spyOn(posthog, 'captureEvent').mockImplementation(() => undefined);
+        mockUseUserContext.mockImplementation(() => ({userModel: {}}));
+        const {rerender} = render(<Component path="/blog/some-post" />);
+
+        await waitFor(() => expect(mockOpen).toHaveBeenCalled());
+        rerender(<Component path="/blog/some-post" />);
+        await waitFor(() => expect(mockOpen).toHaveBeenCalledTimes(2));
+
+        expect(captureEventSpy).toHaveBeenCalledTimes(1);
+        expect(captureEventSpy).toHaveBeenCalledWith('gated_content_viewed');
+        mockUseUserContext.mockReturnValue(userData);
+    });
 });
diff --git a/test/src/pages/details/common/get-this-title-files/order-print-copy/order-print-copy.test.tsx b/test/src/pages/details/common/get-this-title-files/order-print-copy/order-print-copy.test.tsx
index f170c3751..a31d8063a 100644
--- a/test/src/pages/details/common/get-this-title-files/order-print-copy/order-print-copy.test.tsx
+++ b/test/src/pages/details/common/get-this-title-files/order-print-copy/order-print-copy.test.tsx
@@ -4,6 +4,7 @@ import '@testing-library/jest-dom';
 import {IntlProvider} from 'react-intl';
 import OrderPrintCopy from '~/pages/details/common/get-this-title-files/order-print-copy/order-print-copy';
 import * as cmsFetch from '~/helpers/cms-fetch';
+import * as posthog from '~/helpers/posthog';
 
 function Wrapper({children}: {children: React.ReactNode}) {
     return (
@@ -179,4 +180,29 @@ describe('OrderPrintCopy', () => {
             expect(nav?.getAttribute('data-analytics-nav')).toBe('Order print copy');
         });
     });
+
+    it('captures click events for phone and desktop print copy links', async () => {
+        const captureEventSpy = jest.spyOn(posthog, 'captureEvent').mockImplementation(() => undefined);
+        jest.spyOn(cmsFetch, 'default').mockResolvedValue({
+            amazon_link: 'https://example.com/amazon',
+            audiobook_link: 'https://example.com/audiobook'
+        });
+
+        const {container} = render(
+            <Wrapper>
+                <OrderPrintCopy slug="test-book" campaign="book-details" />
+            </Wrapper>
+        );
+
+        await waitFor(() => {
+            expect(container.querySelector('.phone-version .box[data-track=\"Audiobook\"]')).toBeInTheDocument();
+            expect(container.querySelector('.larger-version .btn[data-track=\"Print\"]')).toBeInTheDocument();
+        });
+
+        (container.querySelector('.phone-version .box[data-track=\"Audiobook\"]') as HTMLAnchorElement).click();
+        (container.querySelector('.larger-version .btn[data-track=\"Print\"]') as HTMLAnchorElement).click();
+
+        expect(captureEventSpy).toHaveBeenNthCalledWith(1, 'print_copy_clicked', {format: 'Audiobook'});
+        expect(captureEventSpy).toHaveBeenNthCalledWith(2, 'print_copy_clicked', {format: 'Print'});
+    });
 });
diff --git a/test/src/pages/details/get-this-title/get-this-title.test.tsx b/test/src/pages/details/get-this-title/get-this-title.test.tsx
index 626eb875e..a59103ea2 100644
--- a/test/src/pages/details/get-this-title/get-this-title.test.tsx
+++ b/test/src/pages/details/get-this-title/get-this-title.test.tsx
@@ -127,6 +127,8 @@ describe('get-this-title', () => {
         expect(toggleLink.getAttribute('aria-pressed')).toBe('false');
         await user.click(toggleLink);
         expect(toggleLink.getAttribute('aria-pressed')).toBe('true');
+        await user.click(toggleLink);
+        expect(toggleLink.getAttribute('aria-pressed')).toBe('false');
         mockIsPolish.mockReset();
     });
     it('excludes TOC option for retired books', async () => {
diff --git a/test/src/pages/partners/info-request-form.test.tsx b/test/src/pages/partners/info-request-form.test.tsx
index ed2c26cf2..10133ac89 100644
--- a/test/src/pages/partners/info-request-form.test.tsx
+++ b/test/src/pages/partners/info-request-form.test.tsx
@@ -4,6 +4,7 @@ import userEvent from '@testing-library/user-event';
 import ShellContextProvider from '~/../../test/helpers/shell-context';
 import * as PC from '~/pages/partners/partner-details/partner-context';
 import * as SFBC from '~/components/multiselect/book-tags/sf-book-context';
+import * as FT from '~/components/form-target/form-target';
 import sfBooks from '~/../../test/src/data/sf-all-books';
 import InfoRequestForm from '~/pages/partners/partner-details/info-request-form/info-request-form';
 import {SearchContextProvider} from '~/pages/partners/search-context';
@@ -70,6 +71,29 @@ describe('partners/info-rquest-form', () => {
         renderForm();
         screen.getByText('is an abnormal', {exact: false});
     });
+    it('calls captureEvent and toggleForm after form submission', async () => {
+        const toggleForm = jest.fn();
+
+        mockPC.mockReturnValue({...mockPC1, toggleForm});
+        let capturedAfterSubmit: (() => void) | undefined;
+        const ftSpy = jest.spyOn(FT, 'default').mockImplementation(
+            (cb?: () => void) => {
+                capturedAfterSubmit = cb;
+                return {
+                    onSubmit: jest.fn(),
+                    submitting: false,
+                    FormTarget: jest.fn().mockReturnValue(null)
+                } as unknown as ReturnType<typeof FT.default>;
+            }
+        );
+
+        renderForm();
+        await screen.findByText(/Next/);
+        capturedAfterSubmit?.();
+
+        expect(toggleForm).toHaveBeenCalled();
+        ftSpy.mockRestore();
+    });
 });
 
 describe('school-selector utilities', () => {