diff --git a/src/app/components/content/IsaacVideo.tsx b/src/app/components/content/IsaacVideo.tsx
index e4cef68096..256dbafe2c 100644
--- a/src/app/components/content/IsaacVideo.tsx
+++ b/src/app/components/content/IsaacVideo.tsx
@@ -1,7 +1,7 @@
 import React, { useCallback, useContext, useRef } from "react";
 import { VideoDTO } from "../../../IsaacApiTypes";
 import { selectors, useAppDispatch, useAppSelector } from "../../state";
-import { NOT_FOUND, api, ACTION_TYPE } from "../../services";
+import { NOT_FOUND, api, ACTION_TYPE, API_PATH } from "../../services";
 import ReactGA from "react-ga4";
 import { AccordionSectionContext } from "../../../IsaacAppTypes";
 
@@ -55,6 +55,7 @@ interface YouTubePlayer {
   getVideoUrl: () => string;
   getCurrentTime: () => number;
   getDuration: () => number;
+  destroy?: () => void;
 }
 
 interface YouTubeEvent {
@@ -65,7 +66,7 @@ interface YouTubeEvent {
 declare global {
   interface Window {
     YT?: {
-      Player: new (element: HTMLElement, config: unknown) => void;
+      Player: new (element: HTMLElement, config: unknown) => YouTubePlayer;
       ready: (callback: () => void) => void;
       PlayerState: {
         PLAYING: number;
@@ -76,12 +77,23 @@ declare global {
     Wistia?: {
       [key: string]: unknown;
     };
+    // Wistia's E-v1.js embed exposes a `_wq` command queue; pushing a handler with an
+    // `onReady` callback yields a video API object we can read the true duration from.
+    _wq?: Array<{ id: string; onReady?: (video: WistiaVideoApi) => void; [key: string]: unknown }>;
   }
 
   // eslint-disable-next-line no-var
   var YT: Window["YT"];
   // eslint-disable-next-line no-var
   var Wistia: Window["Wistia"];
+  // eslint-disable-next-line no-var
+  var _wq: Window["_wq"];
+}
+
+interface WistiaVideoApi {
+  duration?: () => number;
+  time?: () => number;
+  [key: string]: unknown;
 }
 
 // Constants
@@ -324,6 +336,19 @@ export function saveVideoProgress(userStorageScope: string | null, videoId: stri
   }
 }
 
+/**
+ * TODO(#855) TEMPORARY diagnostic logging for the video KPI flow — currently logs unconditionally on every
+ * environment (including production). MUST be removed (this block and its call sites) before the prod release.
+ */
+export function videoDebugLog(message: string, data?: Record<string, unknown>): void {
+  try {
+    // eslint-disable-next-line no-console
+    console.info(`[video-kpi] ${message}`, data ?? "");
+  } catch {
+    // ignore (e.g. console unavailable)
+  }
+}
+
 /**
  * Log video events to the backend
  */
@@ -335,15 +360,62 @@ export async function logVideoEvent(
     dispatch({ type: ACTION_TYPE.LOG_EVENT, eventDetails });
   }
 
+  videoDebugLog("logVideoEvent -> POST /log", {
+    type: eventDetails.type,
+    videoId: eventDetails.videoId,
+    watchPercent: eventDetails.watchPercent,
+    watchedSeconds: eventDetails.watchedSeconds,
+    videoDurationSeconds: eventDetails.videoDurationSeconds,
+    dispatched: Boolean(dispatch),
+  });
+
   try {
     await api.logger.log(eventDetails);
+    videoDebugLog("logVideoEvent POST /log succeeded", { type: eventDetails.type, videoId: eventDetails.videoId });
   } catch (error) {
+    videoDebugLog("logVideoEvent POST /log FAILED", {
+      type: eventDetails.type,
+      videoId: eventDetails.videoId,
+      error: error instanceof Error ? error.message : String(error),
+    });
     if (process.env.NODE_ENV === "development") {
       console.warn("Failed to log video event:", error);
     }
   }
 }
 
+/**
+ * Reliably POST a video-engagement event to /log when the page is being hidden/unloaded.
+ *
+ * A normal in-page XHR/axios POST is cancelled by the browser on navigation or tab close, which
+ * silently drops a threshold reached at the last moment. fetch with `keepalive: true` matches the
+ * existing axios request (same JSON content type + credentials, so it satisfies the identical
+ * cookie auth and CORS) but is allowed to outlive the document. Returns whether the request was
+ * dispatched (not whether the server accepted it — there is no response to await during unload).
+ */
+export function sendVideoEngagementBeacon(eventDetails: VideoEventDetails): boolean {
+  try {
+    void fetch(`${API_PATH}/log`, {
+      method: "POST",
+      credentials: "include",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(eventDetails),
+      keepalive: true,
+    });
+    videoDebugLog("sendVideoEngagementBeacon dispatched", {
+      videoId: eventDetails.videoId,
+      watchPercent: eventDetails.watchPercent,
+    });
+    return true;
+  } catch (error) {
+    videoDebugLog("sendVideoEngagementBeacon FAILED", {
+      videoId: eventDetails.videoId,
+      error: error instanceof Error ? error.message : String(error),
+    });
+    return false;
+  }
+}
+
 /**
  * Create video event details object
  */
@@ -493,6 +565,19 @@ export function IsaacVideo(props: IsaacVideoProps) {
   const wistiaIframeRef = useRef<HTMLIFrameElement>(null);
   const youtubePlayerRef = useRef<YouTubePlayer | null>(null);
   const youtubePollTimerRef = useRef<ReturnType<typeof globalThis.setInterval> | null>(null);
+  // The YouTube iframe API is loaded `async` (public/index.html), so `globalThis.YT` is often not
+  // yet defined when this component's div mounts. The ref callback captures the node here; a waiter
+  // effect then constructs the player as soon as YT is available. `youtubePlayerCreatedRef` guards
+  // against constructing twice (ref callback re-fire + waiter poll).
+  const youtubeNodeRef = useRef<HTMLDivElement | null>(null);
+  const youtubePlayerCreatedRef = useRef<boolean>(false);
+  // Set true when onReady fires. Used by the watchdog below to distinguish "handshake still pending /
+  // video not played yet" from "enablejsapi channel never connected" (the latter = no events ever logged).
+  const youtubeReadyFiredRef = useRef<boolean>(false);
+  // Prevents re-sending VIDEO_60_PERCENT_WATCHED while an attempt is in flight. Because the KPI is
+  // now only persisted (thresholdLogged) after the backend confirms, without this guard the
+  // per-tick playback check would fire duplicate requests until the first one resolved.
+  const thresholdSendInFlightRef = useRef<boolean>(false);
 
   const platform = React.useMemo(() => (src ? detectPlatform(src) : null), [src]);
   const isYouTube = platform === "youtube";
@@ -521,28 +606,86 @@ export function IsaacVideo(props: IsaacVideoProps) {
     progressScopeAndVideoRef.current = { userStorageScope, canonicalVideoId };
   }
 
+  // TODO(#855) TEMPORARY diagnostic: log the resolved tracking scope whenever it changes, so it is
+  // obvious whether the 60% KPI is enabled on this video and, if not, exactly why.
+  React.useEffect(() => {
+    videoDebugLog("scope resolved", {
+      userStorageScope,
+      canonicalVideoId,
+      loggedIn: Boolean(user),
+      trackingEnabled: Boolean(userStorageScope && canonicalVideoId),
+      reason: !userStorageScope ? "not-logged-in" : !canonicalVideoId ? "no-canonical-video-id" : "enabled",
+    });
+  }, [userStorageScope, canonicalVideoId, user]);
+
   const setTotalVideoDurationIfPresent = useCallback(
     (totalVideoDurationInSeconds: number | null | undefined) => {
       if (!canonicalVideoId || !isValidNumber(totalVideoDurationInSeconds) || totalVideoDurationInSeconds <= 0) return;
       if (progressReference.current.totalVideoDurationInSeconds === totalVideoDurationInSeconds) return;
       progressReference.current.totalVideoDurationInSeconds = totalVideoDurationInSeconds;
       saveVideoProgress(userStorageScope, canonicalVideoId, progressReference.current);
+      videoDebugLog("video duration captured", { videoId: canonicalVideoId, totalVideoDurationInSeconds });
     },
     [canonicalVideoId, userStorageScope],
   );
 
   const checkIf60PercentWatchedAndLog = useCallback(
-    (videoId: string, videoUrl: string) => {
-      if (!userStorageScope || !canonicalVideoId || progressReference.current.thresholdLogged) return;
+    (videoId: string, videoUrl: string, liveCurrentTime?: number) => {
+      if (
+        !userStorageScope ||
+        !canonicalVideoId ||
+        progressReference.current.thresholdLogged ||
+        thresholdSendInFlightRef.current
+      ) {
+        videoDebugLog("checkIf60% skipped", {
+          videoId,
+          reason: !userStorageScope
+            ? "not-logged-in"
+            : !canonicalVideoId
+            ? "no-video-id"
+            : progressReference.current.thresholdLogged
+            ? "already-logged-this-video"
+            : "send-in-flight",
+        });
+        return;
+      }
       const totalVideoDurationInSeconds = progressReference.current.totalVideoDurationInSeconds;
-      if (!isValidNumber(totalVideoDurationInSeconds) || totalVideoDurationInSeconds <= 0) return;
+      if (!isValidNumber(totalVideoDurationInSeconds) || totalVideoDurationInSeconds <= 0) {
+        videoDebugLog("checkIf60% skipped", { videoId, reason: "no-duration-yet", totalVideoDurationInSeconds });
+        return;
+      }
+
+      // Include the segment currently being watched (not yet committed while playing straight through) so the
+      // KPI fires as soon as cumulative watch time crosses the threshold, without needing a pause/seek/end/unmount.
+      const segments = [...progressReference.current.segments];
+      const openSegmentStart = progressReference.current.currentSegmentStart;
+      if (
+        progressReference.current.isPlaying &&
+        isValidNumber(openSegmentStart) &&
+        isValidNumber(liveCurrentTime) &&
+        liveCurrentTime > openSegmentStart
+      ) {
+        segments.push({ watchedSegmentStart: openSegmentStart, watchedSegmentEnd: liveCurrentTime });
+      }
 
-      const uniqueWatchedSeconds = getUniqueWatchedSeconds(progressReference.current.segments);
+      const uniqueWatchedSeconds = getUniqueWatchedSeconds(mergeSegments(segments));
       const watchPercent = getWatchPercent(uniqueWatchedSeconds, totalVideoDurationInSeconds);
-      if (watchPercent < VIDEO_WATCH_THRESHOLD) return;
+      if (watchPercent < VIDEO_WATCH_THRESHOLD) {
+        videoDebugLog("checkIf60% below threshold", {
+          videoId,
+          watchPercent: Number(watchPercent.toFixed(3)),
+          uniqueWatchedSeconds: Number(uniqueWatchedSeconds.toFixed(1)),
+          totalVideoDurationInSeconds,
+        });
+        return;
+      }
 
-      progressReference.current.thresholdLogged = true;
-      saveVideoProgress(userStorageScope, canonicalVideoId, progressReference.current);
+      videoDebugLog("checkIf60% THRESHOLD REACHED -> logging", {
+        videoId,
+        watchPercent: Number(watchPercent.toFixed(3)),
+        uniqueWatchedSeconds: Number(uniqueWatchedSeconds.toFixed(1)),
+        totalVideoDurationInSeconds,
+      });
 
       const eventDetails = createEventDetails("VIDEO_60_PERCENT_WATCHED", videoUrl, videoId, {
         pageId,
@@ -550,20 +693,54 @@ export function IsaacVideo(props: IsaacVideoProps) {
         watchedSeconds: uniqueWatchedSeconds,
         watchPercent,
       });
-      logVideoEvent(eventDetails, dispatch);
+
+      // Block duplicate sends from later playback ticks until this attempt resolves.
+      thresholdSendInFlightRef.current = true;
+      // Keep the redux LOG_EVENT dispatch (analytics + observability), but only persist
+      // thresholdLogged once the backend has accepted the event. Previously the flag was set
+      // optimistically before the POST, so any failure (transient network, or a backend that
+      // wasn't accepting the event yet) permanently suppressed the KPI for that user+video.
+      dispatch({ type: ACTION_TYPE.LOG_EVENT, eventDetails });
+      api.logger
+        .log(eventDetails)
+        .then(() => {
+          progressReference.current.thresholdLogged = true;
+          saveVideoProgress(userStorageScope, canonicalVideoId, progressReference.current);
+          videoDebugLog("VIDEO_60_PERCENT_WATCHED recorded; thresholdLogged persisted", { videoId });
+        })
+        .catch((error) => {
+          videoDebugLog("VIDEO_60_PERCENT_WATCHED POST failed; will retry on next update", {
+            videoId,
+            error: error instanceof Error ? error.message : String(error),
+          });
+        })
+        .finally(() => {
+          thresholdSendInFlightRef.current = false;
+        });
     },
     [canonicalVideoId, dispatch, pageId, userStorageScope],
   );
 
   const appendSegment = useCallback(
     (segmentStart: number, segmentEnd: number, videoId: string, videoUrl: string) => {
-      if (!userStorageScope) return;
+      // TODO(#855) TEMPORARY diagnostic: log each condition that gates whether a watched segment is
+      // recorded (and therefore whether the 60% check can eventually fire), with the deciding values.
+      if (!userStorageScope) {
+        videoDebugLog("appendSegment SKIPPED", { reason: "not-logged-in", segmentStart, segmentEnd });
+        return;
+      }
       const totalVideoDurationInSeconds = progressReference.current.totalVideoDurationInSeconds;
-      if (!isValidNumber(totalVideoDurationInSeconds) || totalVideoDurationInSeconds <= 0) return;
+      if (!isValidNumber(totalVideoDurationInSeconds) || totalVideoDurationInSeconds <= 0) {
+        videoDebugLog("appendSegment SKIPPED", { reason: "duration-unknown", totalVideoDurationInSeconds });
+        return;
+      }
 
       const clampedStart = clampVideoProgressValue(segmentStart, 0, totalVideoDurationInSeconds);
       const clampedEnd = clampVideoProgressValue(segmentEnd, 0, totalVideoDurationInSeconds);
-      if (clampedEnd - clampedStart < 0.5) return;
+      if (clampedEnd - clampedStart < 0.5) {
+        videoDebugLog("appendSegment SKIPPED", { reason: "segment-too-short", clampedStart, clampedEnd });
+        return;
+      }
 
       progressReference.current.segments = mergeSegments([
         ...progressReference.current.segments,
@@ -578,24 +755,55 @@ export function IsaacVideo(props: IsaacVideoProps) {
   const startCurrentSegment = useCallback((segmentStart: number) => {
     progressReference.current.currentSegmentStart = segmentStart;
     progressReference.current.lastKnownTime = segmentStart; // this will set a baseline time when a new segment starts, so that we can detect seeks
+    // TODO(#855) diagnostic: mark the exact position a new watched segment opens.
+    videoDebugLog("startCurrentSegment", { segmentStart: Number(segmentStart.toFixed(1)) });
   }, []);
 
   const closeCurrentSegment = useCallback(
     (segmentEnd: number, videoUrl: string, videoId: string) => {
       const currentSegmentStart = progressReference.current.currentSegmentStart;
-      if (!isValidNumber(currentSegmentStart)) return;
+      if (!isValidNumber(currentSegmentStart)) {
+        // TODO(#855) diagnostic: closing with no open segment usually means play/pause bookkeeping got out of sync.
+        videoDebugLog("closeCurrentSegment SKIPPED", {
+          reason: "no-open-segment",
+          segmentEnd: Number(segmentEnd.toFixed(1)),
+        });
+        return;
+      }
+      videoDebugLog("closeCurrentSegment", {
+        from: Number(currentSegmentStart.toFixed(1)),
+        to: Number(segmentEnd.toFixed(1)),
+      });
       appendSegment(currentSegmentStart, segmentEnd, videoId, videoUrl);
       progressReference.current.currentSegmentStart = null;
     },
     [appendSegment],
   );
 
+  // Latest closeCurrentSegment, read by the YouTube teardown below without making that effect depend on
+  // (and therefore re-run + tear the player down on) every callback identity change.
+  const closeCurrentSegmentRef = useRef(closeCurrentSegment);
+  closeCurrentSegmentRef.current = closeCurrentSegment;
+
   // this function is used to update the playback progress of the video, and detect seeks by comparing the current time with the last known time.
   const updatePlaybackProgress = useCallback(
     (currentTime: number, videoUrl: string, videoId: string) => {
-      if (!isValidNumber(currentTime)) return;
+      if (!isValidNumber(currentTime)) {
+        // TODO(#855) diagnostic: getCurrentTime() returned a non-number (player not ready?).
+        videoDebugLog("updatePlaybackProgress IGNORED", { reason: "current-time-not-a-number", currentTime });
+        return;
+      }
       const lastKnownTime = progressReference.current.lastKnownTime;
       if (!progressReference.current.isPlaying || !isValidNumber(lastKnownTime)) {
+        // TODO(#855) diagnostic: this is the silent branch — a tick arrives but is dropped before any
+        // "playback tick" log because we think we're not playing or have no baseline time. If ticks
+        // vanish here while the video is visibly playing, isPlaying never got set true on PLAYING.
+        videoDebugLog("updatePlaybackProgress IGNORED", {
+          reason: !progressReference.current.isPlaying ? "not-playing" : "no-baseline-time",
+          isPlaying: progressReference.current.isPlaying,
+          lastKnownTime,
+          currentTime: Number(currentTime.toFixed(1)),
+        });
         progressReference.current.lastKnownTime = currentTime;
         return;
       }
@@ -603,12 +811,37 @@ export function IsaacVideo(props: IsaacVideoProps) {
       const diff = currentTime - lastKnownTime;
       const isSeek = Math.abs(diff) > SEEK_DETECTION_TOLERANCE_SECONDS;
       if (isSeek) {
+        // TODO(#855) diagnostic: a seek splits the open segment; log it so jumps vs. straight play are visible.
+        videoDebugLog("seek detected", {
+          from: Number(lastKnownTime.toFixed(1)),
+          to: Number(currentTime.toFixed(1)),
+          diff: Number(diff.toFixed(1)),
+        });
         closeCurrentSegment(lastKnownTime, videoUrl, videoId);
         startCurrentSegment(currentTime);
       }
       progressReference.current.lastKnownTime = currentTime;
+
+      // TODO(#855) diagnostic: log every playback tick regardless of login state, so the watch progress and the
+      // logged-in/anonymous state are visible even for anonymous sessions (the KPI itself stays logged-in only).
+      const tickTotalDuration = progressReference.current.totalVideoDurationInSeconds;
+      const positionPercent =
+        isValidNumber(tickTotalDuration) && tickTotalDuration > 0 ? currentTime / tickTotalDuration : null;
+      videoDebugLog("playback tick", {
+        videoId,
+        loggedIn: Boolean(userStorageScope),
+        userStorageScope,
+        currentTime: Number(currentTime.toFixed(1)),
+        totalVideoDurationInSeconds: tickTotalDuration,
+        positionPercent: positionPercent == null ? null : Number(positionPercent.toFixed(3)),
+        crossed60ByPosition: positionPercent != null && positionPercent >= VIDEO_WATCH_THRESHOLD,
+      });
+
+      // Evaluate the KPI live during playback (counting the open segment) so it fires without needing a
+      // pause/seek/end/navigation — otherwise a straight watch-through or a tab close never logs the event.
+      checkIf60PercentWatchedAndLog(videoId, videoUrl, currentTime);
     },
-    [closeCurrentSegment, startCurrentSegment],
+    [checkIf60PercentWatchedAndLog, closeCurrentSegment, startCurrentSegment, userStorageScope],
   );
 
   const logPlayerEvent = useCallback(
@@ -625,12 +858,21 @@ export function IsaacVideo(props: IsaacVideoProps) {
 
   // Load Wistia API script
   React.useEffect(() => {
-    if (!isWistia || globalThis.Wistia) return;
+    if (!isWistia) return;
+    if (globalThis.Wistia) {
+      // TODO(#855) diagnostic: Wistia API already present; no injection needed.
+      videoDebugLog("Wistia API already loaded");
+      return;
+    }
 
     const script = document.createElement("script");
     script.src = "https://fast.wistia.com/assets/external/E-v1.js";
     script.async = true;
+    script.addEventListener("load", () => videoDebugLog("Wistia API script LOADED"));
+    script.addEventListener("error", () => videoDebugLog("Wistia API script FAILED to load"));
     document.body.appendChild(script);
+    // TODO(#855) diagnostic: injected the Wistia embed script.
+    videoDebugLog("Wistia API script injected");
   }, [isWistia]);
 
   // Wistia: postMessage API — play/pause/end and time ticks feed the same segment tracker as YouTube
@@ -668,6 +910,14 @@ export function IsaacVideo(props: IsaacVideoProps) {
       }
 
       const eventType = WISTIA_EVENT_TYPE_MAP[eventName.toLowerCase()];
+      // TODO(#855) diagnostic: log every Wistia lifecycle event, mapped type included. If mapped events
+      // never appear while the video plays, the postMessage bindings never took (see "Wistia bindings sent").
+      videoDebugLog("Wistia event", {
+        eventName,
+        mappedType: eventType ?? "(unmapped/ignored)",
+        eventTime: Number(eventTime.toFixed(1)),
+        duration: totalVideoDurationInSeconds,
+      });
       if (!eventType) return;
 
       if (eventType === "VIDEO_PLAY") {
@@ -729,6 +979,12 @@ export function IsaacVideo(props: IsaacVideoProps) {
             "https://fast.wistia.net",
           );
         });
+        // TODO(#855) diagnostic: bind messages posted to the Wistia iframe. Without these, no Wistia
+        // events arrive and the tracker stays silent after "scope resolved".
+        videoDebugLog("Wistia bindings sent", { wistiaVideoId, events: eventsToTrack });
+      } else {
+        // TODO(#855) diagnostic: iframe had no contentWindow after the 1s delay — bindings never sent.
+        videoDebugLog("Wistia bindings SKIPPED", { reason: "no-iframe-contentWindow", wistiaVideoId });
       }
     };
 
@@ -759,31 +1015,70 @@ export function IsaacVideo(props: IsaacVideoProps) {
     if (!youtubePollTimerRef.current) return;
     globalThis.clearInterval(youtubePollTimerRef.current);
     youtubePollTimerRef.current = null;
+    // TODO(#855) diagnostic: the 1s progress poll has stopped (pause/end/unmount).
+    videoDebugLog("YouTube poll timer STOPPED");
   }, []);
 
   const pollYouTubePlayerProgress = useCallback(() => {
     const player = youtubePlayerRef.current;
-    if (!player || !youtubeVideoId) return;
-    updatePlaybackProgress(player.getCurrentTime(), player.getVideoUrl(), youtubeVideoId);
+    if (!player || !youtubeVideoId) {
+      // TODO(#855) diagnostic: poll fired but we have no player/videoId to read from.
+      videoDebugLog("YouTube poll SKIPPED", { hasPlayer: Boolean(player), youtubeVideoId });
+      return;
+    }
+    const currentTime = player.getCurrentTime();
+    // TODO(#855) diagnostic: raw poll reading, before updatePlaybackProgress decides to keep or drop it.
+    videoDebugLog("YouTube poll", {
+      currentTime: isValidNumber(currentTime) ? Number(currentTime.toFixed(1)) : currentTime,
+    });
+    updatePlaybackProgress(currentTime, player.getVideoUrl(), youtubeVideoId);
   }, [updatePlaybackProgress, youtubeVideoId]);
 
   const startYouTubePollTimer = useCallback(() => {
     stopYouTubePollTimer();
     youtubePollTimerRef.current = globalThis.setInterval(pollYouTubePlayerProgress, 1000);
+    // TODO(#855) diagnostic: the 1s progress poll has started (should follow every PLAYING).
+    videoDebugLog("YouTube poll timer STARTED");
   }, [pollYouTubePlayerProgress, stopYouTubePollTimer]);
 
   const handleYouTubePlayerReady = useCallback(
     (event: YouTubeEvent) => {
       youtubePlayerRef.current = event.target;
-      setTotalVideoDurationIfPresent(event.target.getDuration());
+      youtubeReadyFiredRef.current = true;
+      const duration = event.target.getDuration();
+      // TODO(#855) diagnostic: onReady fired — the enablejsapi handshake completed, so onStateChange/KPI
+      // logging will work. If this never appears, the API channel never connected (see the READY WATCHDOG).
+      videoDebugLog("YouTube onReady", { youtubeVideoId, duration });
+      setTotalVideoDurationIfPresent(duration);
     },
-    [setTotalVideoDurationIfPresent],
+    [setTotalVideoDurationIfPresent, youtubeVideoId],
   );
 
   const handleYouTubePlayerStateChange = useCallback(
     (event: YouTubeEvent) => {
       const YT = globalThis.YT;
-      if (!YT || !youtubeVideoId) return;
+      // TODO(#855) diagnostic: name the raw YT state so the console reads playing/paused/ended/buffering/cued
+      // instead of -1..5. -1 unstarted, 0 ended, 1 playing, 2 paused, 3 buffering, 5 cued.
+      const stateName =
+        (
+          { [-1]: "unstarted", 0: "ended", 1: "playing", 2: "paused", 3: "buffering", 5: "cued" } as Record<
+            number,
+            string
+          >
+        )[event.data] ?? String(event.data);
+      videoDebugLog("YouTube onStateChange", {
+        youtubeVideoId,
+        rawState: event.data,
+        stateName,
+        ytPresent: Boolean(YT),
+      });
+      if (!YT || !youtubeVideoId) {
+        // TODO(#855) diagnostic: if this fires we can never process play/pause/end — the whole KPI is dead here.
+        videoDebugLog("handleYouTubePlayerStateChange BAILED", {
+          reason: !YT ? "no-YT-global" : "no-youtube-video-id",
+        });
+        return;
+      }
 
       youtubePlayerRef.current = event.target;
       setTotalVideoDurationIfPresent(event.target.getDuration());
@@ -830,15 +1125,62 @@ export function IsaacVideo(props: IsaacVideoProps) {
     ],
   );
 
-  // YouTube video initialization
+  // YouTube video initialization. The ref callback only *captures the node* — it does NOT construct the
+  // player, because YT may not be loaded yet at mount. Construction happens in the waiter effect below.
   const youtubeRef = useCallback(
     (node: HTMLDivElement | null) => {
-      const YT = globalThis.YT;
-      if (!node || !youtubeVideoId || !YT) return;
+      youtubeNodeRef.current = node;
+      // TODO(#855) diagnostic: entry point of the YouTube KPI chain. `ytPresent:false` here just means the
+      // async iframe API had not loaded yet — the waiter effect will construct the player once it does.
+      videoDebugLog("youtubeRef invoked (node captured)", {
+        hasNode: Boolean(node),
+        youtubeVideoId,
+        ytPresent: Boolean(globalThis.YT),
+      });
+    },
+    [youtubeVideoId],
+  );
 
+  const handleYouTubePlayerError = useCallback(
+    (event: YouTubeEvent) => {
+      // TODO(#855) diagnostic: YouTube reported a player error (2 invalid id, 5 html5, 100 not found,
+      // 101/150 embedding disabled). The KPI cannot run if the video refuses to embed/play.
+      videoDebugLog("YouTube onError", { youtubeVideoId, errorCode: event.data });
+    },
+    [youtubeVideoId],
+  );
+
+  // The player is constructed exactly once, but auth (userStorageScope) and the page doc (pageId) can
+  // resolve AFTER construction. So we register STABLE wrapper handlers that always dispatch to the latest
+  // handler via these refs — otherwise the player would forever call handlers that closed over the
+  // logged-out / no-pageId state, and never log play/pause or the KPI once the user is actually scoped.
+  const handleYouTubePlayerReadyRef = useRef(handleYouTubePlayerReady);
+  handleYouTubePlayerReadyRef.current = handleYouTubePlayerReady;
+  const handleYouTubePlayerStateChangeRef = useRef(handleYouTubePlayerStateChange);
+  handleYouTubePlayerStateChangeRef.current = handleYouTubePlayerStateChange;
+  const handleYouTubePlayerErrorRef = useRef(handleYouTubePlayerError);
+  handleYouTubePlayerErrorRef.current = handleYouTubePlayerError;
+
+  const createYouTubePlayer = useCallback(
+    (container: HTMLDivElement) => {
+      const YT = globalThis.YT;
+      if (!YT || !youtubeVideoId || youtubePlayerCreatedRef.current) return;
+      // Commit before the async YT.ready callback so the waiter poll cannot construct a second player.
+      youtubePlayerCreatedRef.current = true;
       try {
+        videoDebugLog("createYouTubePlayer -> YT.ready(register)", { youtubeVideoId });
         YT.ready(() => {
-          new YT.Player(node, {
+          // Hand YT a plain child node to replace with its <iframe>, NOT the React-managed container
+          // itself. If YT swaps out a React-owned node, the next re-render reconciles that node out from
+          // under the widget and the enablejsapi postMessage handshake targets the wrong window
+          // ("recipient origin = app origin") — so onReady/onStateChange never fire even though the video
+          // plays. React only owns the (childless) container; this child is invisible to its reconciler.
+          const playerHost = document.createElement("div");
+          playerHost.className = "mw-100";
+          container.replaceChildren(playerHost);
+          youtubeReadyFiredRef.current = false;
+          videoDebugLog("YT.ready fired -> new YT.Player", { youtubeVideoId });
+          youtubePlayerRef.current = new YT.Player(playerHost, {
             videoId: youtubeVideoId,
             playerVars: {
               enablejsapi: 1,
@@ -848,37 +1190,213 @@ export function IsaacVideo(props: IsaacVideoProps) {
               origin: globalThis.location.origin,
             },
             events: {
-              onReady: handleYouTubePlayerReady,
-              onStateChange: handleYouTubePlayerStateChange,
+              onReady: (event: YouTubeEvent) => handleYouTubePlayerReadyRef.current(event),
+              onStateChange: (event: YouTubeEvent) => handleYouTubePlayerStateChangeRef.current(event),
+              onError: (event: YouTubeEvent) => handleYouTubePlayerErrorRef.current(event),
             },
           });
+
+          // READY WATCHDOG (TODO(#855)): if onReady has not fired a few seconds after construction, the
+          // enablejsapi handshake did not connect. Dump the real iframe state so we can tell WHY: is there
+          // an <iframe> at all, what is its src (youtube.com vs about:blank), and — the decisive tell —
+          // is its contentWindow same-origin as us (handshake will never work) or cross-origin youtube
+          // (handshake should work). This replaces guessing at the transient postMessage warm-up spam.
+          globalThis.setTimeout(() => {
+            if (youtubeReadyFiredRef.current) return;
+            const iframe = playerHost.querySelector("iframe") ?? container.querySelector("iframe");
+            let contentWindowOrigin: string;
+            try {
+              // Reading .location.origin on a cross-origin (youtube) window THROWS — that's the good case.
+              contentWindowOrigin = iframe?.contentWindow?.location?.origin ?? "(no iframe/contentWindow)";
+            } catch {
+              contentWindowOrigin = "(cross-origin — expected for a loaded youtube iframe)";
+            }
+            videoDebugLog("YouTube READY WATCHDOG: onReady NOT fired ~8s after construction", {
+              youtubeVideoId,
+              iframePresent: Boolean(iframe),
+              iframeSrc: iframe?.getAttribute("src") ?? "(none)",
+              contentWindowOrigin,
+              isPlaying: progressReference.current.isPlaying,
+              hint: "if iframeSrc is about:blank or contentWindowOrigin is our app origin, the youtube iframe never loaded (CSP/network); if it's cross-origin youtube, the video is fine and onReady is just slow/needs play.",
+            });
+          }, 8000);
         });
       } catch (error) {
+        youtubePlayerCreatedRef.current = false; // allow a later retry
         const errorMessage = error instanceof Error ? error.message : "problem with YT library";
         console.error("Error with YouTube library: ", error);
+        videoDebugLog("createYouTubePlayer THREW", { youtubeVideoId, error: errorMessage });
         ReactGA.gtag("event", "exception", {
           description: `youtube_error: ${errorMessage}`,
           fatal: false,
         });
       }
     },
-    [handleYouTubePlayerReady, handleYouTubePlayerStateChange, youtubeVideoId],
+    [youtubeVideoId],
   );
 
-  // Close any open YouTube segment and stop polling when leaving the page or changing video
+  // Latest createYouTubePlayer, read by the waiter effect so it can construct with the current callbacks
+  // WITHOUT listing createYouTubePlayer as a dependency — otherwise every callback-identity change would
+  // re-run the effect, reset the guard, and build a second competing player on the same node.
+  const createYouTubePlayerRef = useRef(createYouTubePlayer);
+  createYouTubePlayerRef.current = createYouTubePlayer;
+
+  // Waiter + lifecycle owner for the YouTube player. Depends ONLY on the platform/video id, so unrelated
+  // re-renders never tear the player down or rebuild it. It (1) constructs the player as soon as both the
+  // container is mounted and the async YT API is loaded, and (2) on video change / unmount, flushes any
+  // open watched segment, stops the poll, and destroys the player so the next construction starts clean.
   React.useEffect(() => {
+    if (!isYouTube || !youtubeVideoId) return;
+    youtubePlayerCreatedRef.current = false; // fresh video id -> allow a new construction
+    let pollTimer: ReturnType<typeof globalThis.setInterval> | null = null;
+    let giveUpTimer: ReturnType<typeof globalThis.setTimeout> | null = null;
+
+    const tryCreate = (): boolean => {
+      const node = youtubeNodeRef.current;
+      if (youtubePlayerCreatedRef.current) return true;
+      if (!node) {
+        videoDebugLog("YT waiter: waiting for node");
+        return false;
+      }
+      if (!globalThis.YT) {
+        videoDebugLog("YT waiter: waiting for YT API to load");
+        return false;
+      }
+      videoDebugLog("YT waiter: node + YT ready -> creating player", { youtubeVideoId });
+      createYouTubePlayerRef.current(node);
+      return true;
+    };
+
+    if (!tryCreate()) {
+      pollTimer = globalThis.setInterval(() => {
+        if (tryCreate() && pollTimer) {
+          globalThis.clearInterval(pollTimer);
+          pollTimer = null;
+        }
+      }, 250);
+      // Give up after a bounded wait so we do not poll forever if the API script failed to load at all.
+      giveUpTimer = globalThis.setTimeout(() => {
+        if (pollTimer) globalThis.clearInterval(pollTimer);
+        if (!youtubePlayerCreatedRef.current) {
+          videoDebugLog("YT waiter: GAVE UP (YT API never loaded / node never mounted)", {
+            youtubeVideoId,
+            hadNode: Boolean(youtubeNodeRef.current),
+            ytPresent: Boolean(globalThis.YT),
+          });
+        }
+      }, 15000);
+    }
+
     return () => {
+      if (pollTimer) globalThis.clearInterval(pollTimer);
+      if (giveUpTimer) globalThis.clearTimeout(giveUpTimer);
       if (youtubePollTimerRef.current) {
         globalThis.clearInterval(youtubePollTimerRef.current);
         youtubePollTimerRef.current = null;
       }
       const player = youtubePlayerRef.current;
-      if (player && youtubeVideoId) {
-        closeCurrentSegment(player.getCurrentTime(), player.getVideoUrl(), youtubeVideoId);
+      // Flush an open segment before teardown (SPA navigate-away / video-change backstop).
+      if (player && progressReference.current.isPlaying) {
+        try {
+          closeCurrentSegmentRef.current(player.getCurrentTime(), player.getVideoUrl(), youtubeVideoId);
+        } catch {
+          /* ignore read/close errors during teardown */
+        }
         progressReference.current.isPlaying = false;
       }
+      if (player?.destroy) {
+        try {
+          player.destroy();
+        } catch {
+          /* ignore */
+        }
+      }
+      youtubePlayerRef.current = null;
+      youtubePlayerCreatedRef.current = false;
+      youtubeNodeRef.current?.replaceChildren();
+      videoDebugLog("YT waiter cleanup: segment flushed + player destroyed", { youtubeVideoId });
     };
-  }, [closeCurrentSegment, youtubeVideoId]);
+  }, [isYouTube, youtubeVideoId]);
+
+  // Unload-safe backstop: when the page is hidden/closed, flush the open segment and, if the 60%
+  // threshold is met but not yet logged, send it via keepalive fetch — a normal POST is cancelled
+  // on unload. This covers a viewer who crosses the threshold and immediately leaves the page.
+  React.useEffect(() => {
+    if (!userStorageScope || !canonicalVideoId) return;
+    const videoUrl = embedSrc || "";
+
+    const flushThreshold = (reason: string) => {
+      if (progressReference.current.thresholdLogged || thresholdSendInFlightRef.current) return;
+      const totalVideoDurationInSeconds = progressReference.current.totalVideoDurationInSeconds;
+      if (!isValidNumber(totalVideoDurationInSeconds) || totalVideoDurationInSeconds <= 0) return;
+
+      const segments = [...progressReference.current.segments];
+      const openSegmentStart = progressReference.current.currentSegmentStart;
+      const openSegmentEnd = progressReference.current.lastKnownTime;
+      if (
+        progressReference.current.isPlaying &&
+        isValidNumber(openSegmentStart) &&
+        isValidNumber(openSegmentEnd) &&
+        openSegmentEnd > openSegmentStart
+      ) {
+        segments.push({ watchedSegmentStart: openSegmentStart, watchedSegmentEnd: openSegmentEnd });
+      }
+      const uniqueWatchedSeconds = getUniqueWatchedSeconds(mergeSegments(segments));
+      const watchPercent = getWatchPercent(uniqueWatchedSeconds, totalVideoDurationInSeconds);
+      if (watchPercent < VIDEO_WATCH_THRESHOLD) return;
+
+      const eventDetails = createEventDetails("VIDEO_60_PERCENT_WATCHED", videoUrl, canonicalVideoId, {
+        pageId,
+        videoDurationSeconds: totalVideoDurationInSeconds,
+        watchedSeconds: uniqueWatchedSeconds,
+        watchPercent,
+      });
+      videoDebugLog("flushThreshold sending on page hide", { reason, videoId: canonicalVideoId, watchPercent });
+      dispatch({ type: ACTION_TYPE.LOG_EVENT, eventDetails });
+      // Beacon is fire-and-forget; mark logged optimistically so a following hide event does not
+      // double-send. A keepalive request is reliably queued once dispatched.
+      if (sendVideoEngagementBeacon(eventDetails)) {
+        progressReference.current.thresholdLogged = true;
+        saveVideoProgress(userStorageScope, canonicalVideoId, progressReference.current);
+      }
+    };
+
+    const onPageHide = () => flushThreshold("pagehide");
+    const onVisibilityChange = () => {
+      if (document.visibilityState === "hidden") flushThreshold("visibilitychange:hidden");
+    };
+
+    globalThis.addEventListener("pagehide", onPageHide);
+    document.addEventListener("visibilitychange", onVisibilityChange);
+    return () => {
+      globalThis.removeEventListener("pagehide", onPageHide);
+      document.removeEventListener("visibilitychange", onVisibilityChange);
+    };
+  }, [userStorageScope, canonicalVideoId, embedSrc, pageId, dispatch]);
+
+  // Wistia: read the true duration via the Wistia JS API. The postMessage "duration" field is not
+  // always present, and without a duration the coverage/threshold calculation is skipped — so
+  // Wistia videos could otherwise never fire VIDEO_60_PERCENT_WATCHED.
+  React.useEffect(() => {
+    if (!isWistia || !wistiaVideoId) return;
+    const wistiaQueue = (globalThis._wq = globalThis._wq || []);
+    wistiaQueue.push({
+      id: wistiaVideoId,
+      onReady: (video: WistiaVideoApi) => {
+        try {
+          const duration = video.duration?.();
+          videoDebugLog("Wistia onReady duration", { wistiaVideoId, duration });
+          if (isValidNumber(duration) && duration > 0) {
+            setTotalVideoDurationIfPresent(duration);
+          }
+        } catch (error) {
+          videoDebugLog("Wistia duration read failed", {
+            error: error instanceof Error ? error.message : String(error),
+          });
+        }
+      },
+    });
+  }, [isWistia, wistiaVideoId, setTotalVideoDurationIfPresent]);
 
   const detailsForPrintOut = <div className="only-print py-2 mb-4">{altTextToUse}</div>;
 
diff --git a/src/app/components/navigation/AuthDebugLogger.tsx b/src/app/components/navigation/AuthDebugLogger.tsx
new file mode 100644
index 0000000000..cf20b22070
--- /dev/null
+++ b/src/app/components/navigation/AuthDebugLogger.tsx
@@ -0,0 +1,37 @@
+import { useEffect } from "react";
+import { useLocation } from "react-router-dom";
+import { selectors, useAppSelector } from "../../state";
+import { debugLog } from "../../services";
+
+/**
+ * TODO(#855) TEMPORARY diagnostic component.
+ *
+ * Logs the app's auth/user view on every navigation (and whenever the user state changes) so we can
+ * see, per page, whether the app considers the user logged in. This is what gates the video KPI:
+ * `loggedInOrNull === null` ⇒ IsaacVideo `userStorageScope === null` ⇒ 60% tracking disabled.
+ *
+ * Renders nothing. Remove before the production release.
+ */
+export const AuthDebugLogger = () => {
+  const location = useLocation();
+  const user = useAppSelector(selectors.user.orNull);
+  const loggedInUser = useAppSelector(selectors.user.loggedInOrNull);
+
+  useEffect(() => {
+    const userId = loggedInUser ? loggedInUser.id : undefined;
+    const userStorageScope = userId == null ? null : String(userId);
+    debugLog("auth", "page visit", {
+      path: location.pathname,
+      loggedIn: user?.loggedIn ?? null,
+      requesting: (user as { requesting?: boolean } | null)?.requesting ?? false,
+      userId,
+      role: loggedInUser ? loggedInUser.role : undefined,
+      loggedInOrNull: loggedInUser ? userId : null,
+      // exactly what IsaacVideo computes; null here means the 60% KPI is disabled on this page
+      userStorageScope,
+      videoKpiEnabled: Boolean(userStorageScope),
+    });
+  }, [location.pathname, user, loggedInUser]);
+
+  return null;
+};
diff --git a/src/app/components/navigation/IsaacApp.tsx b/src/app/components/navigation/IsaacApp.tsx
index 6f7f6705e9..608375ae78 100644
--- a/src/app/components/navigation/IsaacApp.tsx
+++ b/src/app/components/navigation/IsaacApp.tsx
@@ -12,6 +12,7 @@ import {
 } from "../../state";
 import { Route, Router, Switch } from "react-router-dom";
 import ErrorClear from "./ErrorClear";
+import { AuthDebugLogger } from "./AuthDebugLogger";
 import { Footer } from "./Footer";
 import { Question } from "../pages/Question";
 import { Concept } from "../pages/Concept";
@@ -156,6 +157,8 @@ export const IsaacApp = () => {
   // Render
   return (
     <Router history={history}>
+      {/* TODO(#855) TEMPORARY diagnostic: logs auth/user state on every navigation. Remove before prod. */}
+      <AuthDebugLogger />
       <ErrorClear />
       <Header />
       <Toasts />
diff --git a/src/app/services/api.ts b/src/app/services/api.ts
index 22f84f30f7..ed04e43a45 100644
--- a/src/app/services/api.ts
+++ b/src/app/services/api.ts
@@ -1,5 +1,6 @@
 import axios, { AxiosPromise } from "axios";
 import { API_PATH, EventStageFilter, EventTypeFilter, securePadCredentials, securePadPasswordReset, TAG_ID } from "./";
+import { debugLog } from "./debug";
 import * as ApiTypes from "../../IsaacApiTypes";
 import {
   AuthenticationProvider,
@@ -518,7 +519,24 @@ export const api = {
   },
   logger: {
     log: (eventDetails: object): AxiosPromise<void> => {
-      return endpoint.post(`/log`, eventDetails);
+      // TODO(#855) TEMPORARY diagnostic: trace every event POSTed to /log (payload + result).
+      // This is the single choke point all client log events pass through (LOG_EVENT redux action
+      // and IsaacVideo's play/pause/ended/60% logging), so it captures them all.
+      const eventType = (eventDetails as { type?: string })?.type;
+      debugLog("backend-log", "POST /log →", eventDetails);
+      const request = endpoint.post<void>(`/log`, eventDetails);
+      // Side-branch handlers only — the original `request` promise is returned unchanged so callers
+      // still receive success/failure exactly as before.
+      request
+        .then((response) => debugLog("backend-log", "POST /log OK", { status: response.status, type: eventType }))
+        .catch((error) =>
+          debugLog("backend-log", "POST /log FAILED", {
+            status: error?.response?.status,
+            type: eventType,
+            message: error?.message,
+          }),
+        );
+      return request;
     },
   },
   websockets: {
diff --git a/src/app/services/debug.ts b/src/app/services/debug.ts
new file mode 100644
index 0000000000..7e34891b6f
--- /dev/null
+++ b/src/app/services/debug.ts
@@ -0,0 +1,19 @@
+/**
+ * TODO(#855) TEMPORARY diagnostic logging.
+ *
+ * Unconditional console output used to trace, in the browser, exactly what the code sees while we
+ * debug why VIDEO_60_PERCENT_WATCHED is not reaching the backend: the auth/user state on every
+ * page, every event POSTed to /log (payload + result), and the video-KPI decision path including
+ * the conditions that gate whether an event is sent or skipped.
+ *
+ * This is intentionally always-on (not behind a flag) and never logs PII beyond user id + role.
+ * Remove this file and all `debugLog(` call sites before the production release.
+ */
+export function debugLog(scope: string, message: string, data?: unknown): void {
+  try {
+    // eslint-disable-next-line no-console
+    console.info(`[${scope}] ${message}`, data ?? "");
+  } catch {
+    // ignore (e.g. console unavailable)
+  }
+}
diff --git a/src/app/services/index.ts b/src/app/services/index.ts
index 8563708e54..d75ff0fa69 100644
--- a/src/app/services/index.ts
+++ b/src/app/services/index.ts
@@ -1,4 +1,5 @@
 // No internal app dependencies
+export * from "./debug";
 export * from "./localStorage";
 export * from "./siteConstants";
 export * from "./demoTools";
diff --git a/src/app/state/actions/index.tsx b/src/app/state/actions/index.tsx
index 2e6e2945f7..5f7995672d 100644
--- a/src/app/state/actions/index.tsx
+++ b/src/app/state/actions/index.tsx
@@ -3,6 +3,7 @@ import {
   ACTION_TYPE,
   api,
   API_REQUEST_FAILURE_MESSAGE,
+  debugLog,
   atLeastOne,
   augmentEvent,
   DOCUMENT_TYPE,
@@ -196,13 +197,25 @@ export const getUserPreferences = () => async (dispatch: Dispatch<Action>) => {
 
 export const requestCurrentUser = () => async (dispatch: Dispatch<Action>) => {
   dispatch({ type: ACTION_TYPE.CURRENT_USER_REQUEST });
+  // TODO(#855) TEMPORARY diagnostic: trace the current_user lifecycle so we can see exactly when
+  // and why the app flips to anonymous (which disables the video KPI).
+  debugLog("auth", "current_user request");
   try {
     // Request the user
     const currentUser = await api.users.getCurrent();
     // Now with that information request auth settings and preferences asynchronously
     await Promise.all([dispatch(getUserAuthSettings() as any), dispatch(getUserPreferences() as any)]);
+    debugLog("auth", "current_user OK", {
+      userId: currentUser.data?.id,
+      role: currentUser.data?.role,
+      loggedIn: true,
+    });
     dispatch({ type: ACTION_TYPE.CURRENT_USER_RESPONSE_SUCCESS, user: currentUser.data });
   } catch (e) {
+    debugLog("auth", "current_user FAILED (app is now anonymous)", {
+      status: (e as { response?: { status?: number } })?.response?.status,
+      message: (e as Error)?.message,
+    });
     dispatch({ type: ACTION_TYPE.CURRENT_USER_RESPONSE_FAILURE });
   }
 };
diff --git a/src/test/components/elements/content/IsaacVideo.test.tsx b/src/test/components/elements/content/IsaacVideo.test.tsx
index 2d8d3762c6..2f7fbc3541 100644
--- a/src/test/components/elements/content/IsaacVideo.test.tsx
+++ b/src/test/components/elements/content/IsaacVideo.test.tsx
@@ -22,6 +22,7 @@ import {
   processWistiaMessage,
   rewrite,
   saveVideoProgress,
+  sendVideoEngagementBeacon,
   updateWistiaTimeFromArgs,
   updateWistiaTimeFromEventData,
 } from "../../../../app/components/content/IsaacVideo";
@@ -238,6 +239,52 @@ describe("YouTube player handlers", () => {
 
     expect(dispatchMock).not.toHaveBeenCalled();
   });
+
+  it("logs VIDEO_60_PERCENT_WATCHED during continuous playback, without a pause/seek/end", async () => {
+    // Regression: the KPI must fire live from the playback poll while the segment is still open. Previously it
+    // was only evaluated when a segment closed (pause/seek/end/unmount), so a straight watch-through never logged.
+    let currentTime = 0;
+    const advancingPlayer = {
+      getVideoUrl: () => youtubeSrc,
+      getCurrentTime: () => currentTime,
+      getDuration: () => 120,
+    };
+
+    renderYouTubeVideo();
+    await flushPromises();
+
+    const dispatchMock = store.dispatch as jest.Mock;
+
+    // Fake timers must be active BEFORE play so the 1s poll interval is registered as a fake timer we can advance.
+    jest.useFakeTimers();
+    try {
+      // Start playback at t=0 (opens a segment and starts the 1s poll timer).
+      await act(async () => {
+        capturedPlayerConfig?.events?.onStateChange?.({ target: advancingPlayer, data: 1 });
+      });
+      dispatchMock.mockClear();
+
+      // Advance the player one second per poll tick (below the seek tolerance) up past 60% of 120s (= 72s).
+      for (let second = 1; second <= 75; second++) {
+        currentTime = second;
+        act(() => {
+          jest.advanceTimersByTime(1000);
+        });
+      }
+    } finally {
+      jest.useRealTimers();
+    }
+
+    type LoggedAction = { type?: string; eventDetails?: { type?: string; videoId?: string; watchPercent?: number } };
+    const thresholdLog = dispatchMock.mock.calls.find(([action]) => {
+      const a = action as LoggedAction;
+      return a?.type === ACTION_TYPE.LOG_EVENT && a?.eventDetails?.type === "VIDEO_60_PERCENT_WATCHED";
+    });
+    expect(thresholdLog).toBeDefined();
+    const eventDetails = (thresholdLog?.[0] as LoggedAction).eventDetails;
+    expect(eventDetails?.videoId).toBe(youtubeVideoId);
+    expect(eventDetails?.watchPercent).toBeGreaterThanOrEqual(0.6);
+  });
 });
 
 describe("Wistia helpers", () => {
@@ -1363,3 +1410,47 @@ describe("pauseAllVideos", () => {
     iframe.remove();
   });
 });
+
+describe("sendVideoEngagementBeacon", () => {
+  const eventDetails = {
+    type: "VIDEO_60_PERCENT_WATCHED" as const,
+    videoId: "test123ABCde",
+    videoUrl: "https://www.youtube.com/watch?v=test123ABCde",
+    videoDurationSeconds: 120,
+    watchedSeconds: 80,
+    watchPercent: 0.66,
+  };
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it("POSTs the event to /log via fetch with keepalive so it survives page unload", () => {
+    const fetchMock = jest.fn(() => Promise.resolve({ ok: true } as Response));
+    jest.spyOn(globalThis, "fetch").mockImplementation(fetchMock as unknown as typeof fetch);
+
+    const dispatched = sendVideoEngagementBeacon(eventDetails);
+
+    expect(dispatched).toBe(true);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    const [url, init] = fetchMock.mock.calls[0] as unknown as [string, RequestInit];
+    expect(url).toMatch(/\/log$/);
+    expect(init.method).toBe("POST");
+    expect(init.keepalive).toBe(true);
+    expect(init.credentials).toBe("include");
+    expect(init.headers).toMatchObject({ "Content-Type": "application/json" });
+    expect(JSON.parse(init.body as string)).toMatchObject({
+      type: "VIDEO_60_PERCENT_WATCHED",
+      videoId: "test123ABCde",
+    });
+  });
+
+  it("returns false and does not throw when fetch is unavailable", () => {
+    jest.spyOn(globalThis, "fetch").mockImplementation(() => {
+      throw new Error("fetch unavailable");
+    });
+
+    expect(() => sendVideoEngagementBeacon(eventDetails)).not.toThrow();
+    expect(sendVideoEngagementBeacon(eventDetails)).toBe(false);
+  });
+});