@@ -656,13 +656,15 @@
     cursor: pointer;
   }
   #visitsTable .goToFrameBtn:hover { background: var(--panel-bg); }
-  #measuresTableWrap { overflow-x: auto; margin-top: 1rem; max-width: 32rem; }
+  #measuresTableWrap { overflow-x: auto; margin-top: 1rem; max-width: 42rem; }
   #measuresTable { border-collapse: collapse; width: 100%; font-size: 0.9rem; }
   #measuresTable th, #measuresTable td { text-align: left; padding: 0.4rem 0.6rem; border-bottom: 1px solid var(--border); }
   #measuresTable td:first-child { color: var(--accent); vertical-align: top; }
   #measuresTable summary { cursor: pointer; }
   #measuresTable summary::marker { color: var(--accent); }
   #measuresTable .measure-def { margin: 0.4rem 0 0 0; color: var(--fg); font-size: 0.85rem; max-width: 26rem; }
+  #measuresTable .measure-frame-links { display: flex; flex-wrap: wrap; gap: 0.3rem; }
+  #measuresTable .measure-frame-links button { font-size: 0.8rem; padding: 0.15rem 0.4rem; }
   #measuresTable tr.status-not-reached td, #measuresTable tr.status-undetermined td { color: #8a5a00; }
   #measuresTable .audited-badge {
     display: inline-block;
@@ -927,7 +929,7 @@ <h3>Measures</h3>
     <div id="measuresTableWrap" hidden>
       <table id="measuresTable">
         <thead>
-          <tr><th>Measure</th><th>Value</th></tr>
+          <tr><th>Measure</th><th>Value</th><th>Frame</th></tr>
         </thead>
         <tbody id="measuresTableBody"></tbody>
       </table>
 
@@ -2920,36 +2920,59 @@ const MEASURE_DEFINITIONS = {
     'Quadrant time - adjacent (-1)': '% of time in the quarter next to the target, the other direction around the ring.',
 };
 
+// Every measure links back to whatever frame(s) actually produced it (hard
+// rule #6) - a single event (latency, hole deviation) gets one button; a
+// count derived from several visits (errors, revisits) gets one button per
+// contributing visit rather than one symbolic link, so nothing is silently
+// collapsed. Trial-wide aggregates (path length, speed, quadrant time)
+// aren't tied to one event, so they link the trial-start frame instead,
+// labeled honestly as an anchor rather than "the" producing frame.
+function frameLinksHtml(frames, label) {
+    const list = (Array.isArray(frames) ? frames : [frames]).filter(f => f !== null && f !== undefined);
+    if (list.length === 0) return '-';
+    return `<span class="measure-frame-links">${list.map(f =>
+        `<button type="button" class="goToFrameBtn" data-frame="${f}">${label ? label : `Go to frame ${f}`}</button>`
+    ).join('')}</span>`;
+}
+
 // name="measure-detail" makes these a native accordion (Chrome 120+,
 // Firefox 125+, already assumed by the WebCodecs requirement) - opening
 // one closes whichever other definition was open, no JS needed.
-function measureRow(label, valueHtml, statusClass, audited) {
+function measureRow(label, valueHtml, statusClass, audited, frameHtml) {
     const def = MEASURE_DEFINITIONS[label];
     const labelHtml = def
         ? `<details name="measure-detail"><summary>${label}</summary><p class="measure-def">${def}</p></details>`
         : label;
-    return `<tr class="${statusClass || ''}"><td>${labelHtml}</td><td>${valueHtml}${audited ? ' <span class="audited-badge">audited</span>' : ''}</td></tr>`;
+    return `<tr class="${statusClass || ''}"><td>${labelHtml}</td><td>${valueHtml}${audited ? ' <span class="audited-badge">audited</span>' : ''}</td><td>${frameHtml || '-'}</td></tr>`;
 }
 
 function renderMeasuresTable(m) {
+    const trialStartLink = frameLinksHtml(m.trialStartFrame, 'Go to trial start');
     const rows = [
-        measureRow('Primary latency', formatLatency(m.primaryLatency), m.primaryLatency.status !== 'ok' ? 'status-not-reached' : '', m.primaryLatency.audited),
-        measureRow('Total latency', formatLatency(m.totalLatency), m.totalLatency.status !== 'ok' ? `status-${m.totalLatency.status}` : '', m.totalLatency.audited),
-        measureRow('Primary errors', m.primaryErrors.value, '', m.primaryErrors.audited),
-        measureRow('Total errors', m.totalErrors.value, '', m.totalErrors.audited),
-        measureRow('Working memory errors', m.workingMemoryErrors.value, '', m.workingMemoryErrors.audited),
-        measureRow('Perseverative errors', m.perseverativeErrors.value, '', m.perseverativeErrors.audited),
-        measureRow('Hole deviation score', m.holeDeviationScore.value !== null ? m.holeDeviationScore.value : '-', '', m.holeDeviationScore.audited),
-        measureRow('Commitment delay', formatCommitmentDelay(m.commitmentDelay), m.commitmentDelay.status !== 'ok' ? 'status-not-reached' : '', m.commitmentDelay.audited),
-        measureRow('Target re-visit count', m.targetRevisitCount.value !== null ? m.targetRevisitCount.value : '-', '', m.targetRevisitCount.audited),
-        measureRow('Path length', `${m.pathLengthCm.toFixed(1)} cm`),
-        measureRow('Average speed', m.avgSpeedCmS !== null ? `${m.avgSpeedCmS.toFixed(2)} cm/s` : '-'),
-        measureRow('Quadrant time - target', m.quadrantPct[0] !== null ? `${m.quadrantPct[0].toFixed(1)}%` : '-'),
-        measureRow('Quadrant time - adjacent (+1)', m.quadrantPct[1] !== null ? `${m.quadrantPct[1].toFixed(1)}%` : '-'),
-        measureRow('Quadrant time - opposite', m.quadrantPct[2] !== null ? `${m.quadrantPct[2].toFixed(1)}%` : '-'),
-        measureRow('Quadrant time - adjacent (-1)', m.quadrantPct[3] !== null ? `${m.quadrantPct[3].toFixed(1)}%` : '-'),
+        measureRow('Primary latency', formatLatency(m.primaryLatency), m.primaryLatency.status !== 'ok' ? 'status-not-reached' : '', m.primaryLatency.audited, frameLinksHtml(m.primaryLatency.frame)),
+        measureRow('Total latency', formatLatency(m.totalLatency), m.totalLatency.status !== 'ok' ? `status-${m.totalLatency.status}` : '', m.totalLatency.audited, frameLinksHtml(m.totalLatency.frame)),
+        measureRow('Primary errors', m.primaryErrors.value, '', m.primaryErrors.audited, frameLinksHtml(m.primaryErrors.frames)),
+        measureRow('Total errors', m.totalErrors.value, '', m.totalErrors.audited, frameLinksHtml(m.totalErrors.frames)),
+        measureRow('Working memory errors', m.workingMemoryErrors.value, '', m.workingMemoryErrors.audited, frameLinksHtml(m.workingMemoryErrors.frames)),
+        measureRow('Perseverative errors', m.perseverativeErrors.value, '', m.perseverativeErrors.audited, frameLinksHtml(m.perseverativeErrors.frames)),
+        measureRow('Hole deviation score', m.holeDeviationScore.value !== null ? m.holeDeviationScore.value : '-', '', m.holeDeviationScore.audited, frameLinksHtml(m.holeDeviationScore.frame)),
+        measureRow('Commitment delay', formatCommitmentDelay(m.commitmentDelay), m.commitmentDelay.status !== 'ok' ? 'status-not-reached' : '', m.commitmentDelay.audited, frameLinksHtml(m.commitmentDelay.frames)),
+        measureRow('Target re-visit count', m.targetRevisitCount.value !== null ? m.targetRevisitCount.value : '-', '', m.targetRevisitCount.audited, frameLinksHtml(m.targetRevisitCount.frames)),
+        measureRow('Path length', `${m.pathLengthCm.toFixed(1)} cm`, '', false, trialStartLink),
+        measureRow('Average speed', m.avgSpeedCmS !== null ? `${m.avgSpeedCmS.toFixed(2)} cm/s` : '-', '', false, trialStartLink),
+        measureRow('Quadrant time - target', m.quadrantPct[0] !== null ? `${m.quadrantPct[0].toFixed(1)}%` : '-', '', false, trialStartLink),
+        measureRow('Quadrant time - adjacent (+1)', m.quadrantPct[1] !== null ? `${m.quadrantPct[1].toFixed(1)}%` : '-', '', false, trialStartLink),
+        measureRow('Quadrant time - opposite', m.quadrantPct[2] !== null ? `${m.quadrantPct[2].toFixed(1)}%` : '-', '', false, trialStartLink),
+        measureRow('Quadrant time - adjacent (-1)', m.quadrantPct[3] !== null ? `${m.quadrantPct[3].toFixed(1)}%` : '-', '', false, trialStartLink),
     ];
     measuresTableBody.innerHTML = rows.join('');
+
+    measuresTableBody.querySelectorAll('.goToFrameBtn').forEach((btn) => {
+        btn.addEventListener('click', async () => {
+            await showFrame(parseInt(btn.dataset.frame, 10));
+            canvas.scrollIntoView({ behavior: 'smooth', block: 'center' });
+        });
+    });
 }
 
 classifierBtn.addEventListener('click', runClassification);
 
@@ -141,16 +141,18 @@ function computeMeasures(trackResult, visits, confirmedROI, fps, eventOverrides)
     const nonTargetVisits = realVisits.filter(v => v.holeIndex !== targetHoleIndex).sort((a, b) => a.startFrame - b.startFrame);
 
     const primaryLatency = targetVisits.length > 0
-        ? { status: 'ok', value: (targetVisits[0].startFrame - trialStartFrame) / fps, audited: anyOverrideBefore(targetVisits[0].startFrame + 1) }
-        : { status: 'not-reached', value: null, audited: anyOverrideBefore(Infinity) };
+        ? { status: 'ok', value: (targetVisits[0].startFrame - trialStartFrame) / fps, audited: anyOverrideBefore(targetVisits[0].startFrame + 1), frame: targetVisits[0].startFrame }
+        : { status: 'not-reached', value: null, audited: anyOverrideBefore(Infinity), frame: null };
     const primaryErrorFrame = targetVisits.length > 0 ? targetVisits[0].startFrame : Infinity;
-    const primaryErrors = { value: nonTargetVisits.filter(v => v.startFrame < primaryErrorFrame).length, audited: anyOverrideBefore(primaryErrorFrame) };
+    const primaryErrorVisits = nonTargetVisits.filter(v => v.startFrame < primaryErrorFrame);
+    const primaryErrors = { value: primaryErrorVisits.length, audited: anyOverrideBefore(primaryErrorFrame), frames: primaryErrorVisits.map(v => v.startFrame) };
 
     const totalLatencyResolved = resolveTotalLatency(classified, targetHoleIndex);
     const totalLatency = {
         status: totalLatencyResolved.status,
         value: totalLatencyResolved.status === 'ok' ? (totalLatencyResolved.frame - trialStartFrame) / fps : null,
         audited: totalLatencyResolved.audited,
+        frame: totalLatencyResolved.frame,
     };
     // No defined total-latency frame (not reached, or undetermined) ->
     // whole-trial fallback, same reasoning as primary's never-reached case.
@@ -161,33 +163,34 @@ function computeMeasures(trackResult, visits, confirmedROI, fps, eventOverrides)
     // overridden (e.g. excluded as thigmotaxis, which changes the count
     // without moving the boundary).
     const totalAudited = totalLatencyResolved.audited || anyOverrideBefore(totalErrorFrame);
-    const totalErrors = { value: totalErrorVisits.length, audited: totalAudited };
+    const totalErrors = { value: totalErrorVisits.length, audited: totalAudited, frames: totalErrorVisits.map(v => v.startFrame) };
 
     // Working memory error (Gawel et al. 2019, Table 1, citing O'Leary &
     // Brown): re-checking a wrong hole already visited this trial, ANY
     // number of other holes in between allowed - this is what was
     // originally built here under the more confusing name "perseverative."
     const visitCountByHole = new Map();
+    const workingMemoryFrames = [];
     for (const v of totalErrorVisits) {
-        visitCountByHole.set(v.holeIndex, (visitCountByHole.get(v.holeIndex) || 0) + 1);
+        const seen = (visitCountByHole.get(v.holeIndex) || 0) + 1;
+        visitCountByHole.set(v.holeIndex, seen);
+        if (seen > 1) workingMemoryFrames.push(v.startFrame); // the re-check itself, not the original visit
     }
-    let workingMemoryCount = 0;
-    for (const count of visitCountByHole.values()) workingMemoryCount += Math.max(0, count - 1);
-    const workingMemoryErrors = { value: workingMemoryCount, audited: totalAudited };
+    const workingMemoryErrors = { value: workingMemoryFrames.length, audited: totalAudited, frames: workingMemoryFrames };
 
     // Perseverative error, strict definition (same source): re-checking
     // the SAME wrong hole with NO other hole - target included - visited
     // in between. A back-to-back fixation, not just "forgot eventually."
     // Needs the full ordered sequence (target visits count as "another
     // hole" for breaking the streak), not just non-target visits.
     const fullSequence = realVisits.filter(v => v.startFrame < totalErrorFrame).sort((a, b) => a.startFrame - b.startFrame);
-    let strictPerseverativeCount = 0;
+    const perseverativeFrames = [];
     for (let i = 1; i < fullSequence.length; i++) {
         if (fullSequence[i].holeIndex === fullSequence[i - 1].holeIndex && fullSequence[i].holeIndex !== targetHoleIndex) {
-            strictPerseverativeCount++;
+            perseverativeFrames.push(fullSequence[i].startFrame); // the repeat check itself
         }
     }
-    const perseverativeErrors = { value: strictPerseverativeCount, audited: totalAudited };
+    const perseverativeErrors = { value: perseverativeFrames.length, audited: totalAudited, frames: perseverativeFrames };
 
     // Hole deviation score (Gawel et al. 2019, Table 1): circular distance
     // from the target to whichever hole was checked FIRST in the trial -
@@ -207,8 +210,8 @@ function computeMeasures(trackResult, visits, confirmedROI, fps, eventOverrides)
     // independent correctness audit, see
     // audits/2026-09-04-correctness-audit.md finding #5.
     const holeDeviationScore = firstVisitOverall
-        ? { value: circularHoleDistance(firstVisitOverall.holeIndex, targetHoleIndex, holes.length), audited: anyOverrideBefore(firstVisitOverall.startFrame + 1) }
-        : { value: null, audited: false };
+        ? { value: circularHoleDistance(firstVisitOverall.holeIndex, targetHoleIndex, holes.length), audited: anyOverrideBefore(firstVisitOverall.startFrame + 1), frame: firstVisitOverall.startFrame }
+        : { value: null, audited: false, frame: null };
 
     // Post-arrival "commitment" - her own observation from test53's real
     // event trace (early pokes at the target hole, then a later one that
@@ -225,21 +228,22 @@ function computeMeasures(trackResult, visits, confirmedROI, fps, eventOverrides)
     // AND entered) - not-applicable otherwise, same "say so honestly"
     // posture as every other status here, rather than a misleading 0/null.
     const commitmentDelay = (primaryLatency.status === 'ok' && totalLatency.status === 'ok')
-        ? { status: 'ok', value: totalLatency.value - primaryLatency.value, audited: primaryLatency.audited || totalLatency.audited }
-        : { status: 'not-applicable', value: null, audited: primaryLatency.audited || totalLatency.audited };
+        ? { status: 'ok', value: totalLatency.value - primaryLatency.value, audited: primaryLatency.audited || totalLatency.audited, frames: [primaryLatency.frame, totalLatency.frame] }
+        : { status: 'not-applicable', value: null, audited: primaryLatency.audited || totalLatency.audited, frames: [] };
 
     // How many separate visits to the target hole happened before the one
     // that finally resolved to entry - reuses totalErrorFrame (already the
     // entry visit's own frame, or Infinity if never entered) so this can
     // never disagree with total latency/errors about which window counts.
+    const targetRevisitFrames = targetVisits.filter(v => v.startFrame < totalErrorFrame).map(v => v.startFrame);
     const targetRevisitCount = totalLatencyResolved.status === 'ok'
-        ? { value: targetVisits.filter(v => v.startFrame < totalErrorFrame).length, audited: totalAudited }
-        : { value: null, audited: totalAudited };
+        ? { value: targetRevisitFrames.length, audited: totalAudited, frames: targetRevisitFrames }
+        : { value: null, audited: totalAudited, frames: [] };
 
     return {
         available: true,
         primaryLatency, totalLatency, primaryErrors, totalErrors, workingMemoryErrors, perseverativeErrors, holeDeviationScore,
         commitmentDelay, targetRevisitCount,
-        pathLengthCm, avgSpeedCmS, quadrantPct,
+        pathLengthCm, avgSpeedCmS, quadrantPct, trialStartFrame,
     };
 }
@@ -182,6 +182,41 @@ test('computeMeasures does not dilute average speed with time after the mouse st
     assert.ok(Math.abs(measures.avgSpeedCmS - 45) < 1e-9, `expected ~45 cm/s, got ${measures.avgSpeedCmS}`);
 });
 
+// Hard rule #6: every reported number links back to the frame that
+// produced it. Latency/hole-deviation are single-event derived, so they
+// carry one frame; error/revisit counts are derived from several visits,
+// so they carry the frames array of every contributing visit rather than
+// one symbolic anchor.
+test('measures carry the frame(s) that actually produced each number', () => {
+    const measures = commitmentFixture([
+        { holeIndex: 1, startFrame: 2, endFrame: 3, events: [{ holeIndex: 1, startFrame: 2, endFrame: 3 }], type: 'poke' }, // error before primary latency window closes
+        { holeIndex: 2, startFrame: 5, endFrame: 6, events: [{ holeIndex: 2, startFrame: 5, endFrame: 6 }], type: 'poke' }, // primary latency frame
+        { holeIndex: 0, startFrame: 10, endFrame: 11, events: [{ holeIndex: 0, startFrame: 10, endFrame: 11 }], type: 'poke' }, // total-only error
+        { holeIndex: 0, startFrame: 15, endFrame: 16, events: [{ holeIndex: 0, startFrame: 15, endFrame: 16 }], type: 'poke' }, // working-memory re-check of hole 0
+        { holeIndex: 2, startFrame: 20, endFrame: 21, events: [{ holeIndex: 2, startFrame: 20, endFrame: 21 }], type: 'entry' }, // total latency frame
+    ]);
+    assert.equal(measures.primaryLatency.frame, 5);
+    assert.equal(measures.totalLatency.frame, 20);
+    assert.deepEqual(toPlain(measures.primaryErrors.frames), [2]); // only the wrong-hole check before the target was first reached
+    assert.deepEqual(toPlain(measures.totalErrors.frames), [2, 10, 15]);
+    assert.deepEqual(toPlain(measures.workingMemoryErrors.frames), [15]); // only the re-check, not hole 0's first visit
+    assert.equal(measures.holeDeviationScore.frame, 2); // the very first visit overall, not the first target visit
+    assert.deepEqual(toPlain(measures.commitmentDelay.frames), [5, 20]); // both endpoints of the delta
+    assert.deepEqual(toPlain(measures.targetRevisitCount.frames), [5]); // the earlier target visit before entry
+    assert.equal(measures.trialStartFrame, 0);
+});
+
+test('frame fields are null/empty (not missing) when a measure has nothing to link to', () => {
+    const measures = commitmentFixture([]); // nothing happened this trial
+    assert.equal(measures.primaryLatency.frame, null);
+    assert.equal(measures.totalLatency.frame, null);
+    assert.deepEqual(toPlain(measures.primaryErrors.frames), []);
+    assert.deepEqual(toPlain(measures.totalErrors.frames), []);
+    assert.equal(measures.holeDeviationScore.frame, null);
+    assert.deepEqual(toPlain(measures.commitmentDelay.frames), []);
+    assert.deepEqual(toPlain(measures.targetRevisitCount.frames), []);
+});
+
 test('quadrantIndex centers quadrant 0 on the target angle, straddling the wraparound boundary', () => {
     assert.equal(quadrantIndex(0, 0), 0);
     assert.equal(quadrantIndex(44, 0), 0);