timeout works now

docs/timeout_ground_truth.md

@@ -0,0 +1,206 @@
+# Timeout Ground Truth
+
+## Video: OSU vs Tenn 12.21.24.mkv
+
+### Timeout Events (Chronological)
+
+| Timestamp | Seconds | Team | Notes |
+|-----------|---------|------|-------|
+| 4:25 | 265 | HOME | First timeout of the game |
+| 1:07:30 | 4050 | AWAY | |
+| 1:09:40 | 4180 | AWAY | |
+| 1:14:07 | 4447 | HOME | |
+| 1:16:06 | 4566 | HOME | |
+| 1:17:32 | - | - | **Halftime** - All timeouts hidden |
+| 1:20:53 | - | - | Scorebug reappears, timeouts reset to 3 each |
+| 1:44:54 | 6294 | AWAY | |
+| 2:22:30 | - | - | **Game Over** - All timeouts hidden |
+
+### Summary by Half
+
+**First Half:**
+- HOME: 3 timeouts used (4:25, 1:14:07, 1:16:06)
+- AWAY: 2 timeouts used (1:07:30, 1:09:40)
+
+**Second Half:**
+- AWAY: 1 timeout used (1:44:54)
+
+### Total Timeouts to Detect: 6
+
+---
+
+## v4 Baseline Timeout Tracker Performance
+
+### Detected Timeouts (17 total from v4_baseline.json)
+
+| Play # | Timestamp | Seconds | Team | Ground Truth Match |
+|--------|-----------|---------|------|-------------------|
+| 4 | 4:26 | 266 | HOME | ✓ Matches 4:25 |
+| 10 | 9:19 | 559 | HOME | ✗ False positive |
+| 15 | 12:58 | 778 | HOME | ✗ False positive |
+| 21 | 17:37 | 1057 | HOME | ✗ False positive |
+| 35 | 29:05 | 1745 | HOME | ✗ False positive |
+| 60 | 48:21 | 2901 | HOME | ✗ False positive |
+| 68 | 55:04 | 3304 | HOME | ✗ False positive |
+| 79 | 1:02:24 | 3744 | HOME | ✗ False positive |
+| 91 | 1:11:54 | 4314 | HOME | ✗ False positive |
+| 102 | 1:23:48 | 5028 | AWAY | ✗ False positive |
+| 104 | 1:25:40 | 5140 | HOME | ✗ False positive |
+| 111 | 1:30:35 | 5435 | HOME | ✗ False positive |
+| 131 | 1:44:48 | 6288 | AWAY | ✓ Matches 1:44:54 |
+| 146 | 1:57:54 | 7074 | HOME | ✗ False positive |
+| 151 | 2:01:50 | 7310 | HOME | ✗ False positive |
+| 155 | 2:04:52 | 7492 | HOME | ✗ False positive |
+| 175 | 2:18:51 | 8331 | AWAY | ✗ False positive |
+
+### Ground Truth Comparison
+
+| Ground Truth | Detected? | Notes |
+|--------------|-----------|-------|
+| 4:25 (HOME) | ✓ Play 4 at 4:26 | 1 second off |
+| 1:07:30 (AWAY) | ✗ MISSED | No detection near this time |
+| 1:09:40 (AWAY) | ✗ MISSED | No detection near this time |
+| 1:14:07 (HOME) | ✗ MISSED | No detection near this time |
+| 1:16:06 (HOME) | ✗ MISSED | No detection near this time |
+| 1:44:54 (AWAY) | ✓ Play 131 at 1:44:48 | 6 seconds off |
+
+### Performance Summary
+
+- **True Positives**: 2 (detected correctly)
+- **False Negatives**: 4 (missed real timeouts)
+- **False Positives**: 15 (incorrectly flagged as timeout)
+- **Recall**: 2/6 = **33%**
+- **Precision**: 2/17 = **12%**
+
+### Key Observations
+
+1. **Most first-half timeouts missed**: 4 out of 5 first-half timeouts not detected
+2. **High false positive rate**: 15 false positives, mostly flagged as HOME
+3. **Timeout indicator region may be misconfigured**: The detector appears to trigger on 40->25 play clock transitions that aren't actual timeouts
+4. **Second half better**: The one second-half timeout (1:44:54) was detected
+
+---
+
+## Root Cause Analysis
+
+### How Timeout Detection Works
+
+1. **Trigger**: Timeout detection is only triggered when a 40→25 play clock transition is detected
+2. **Classification**: When 40→25 occurs, `classify_40_to_25_reset()` is called which:
+   - Compares current timeout counts with last known values via `check_timeout_change()`
+   - If `timeout_info.home_timeouts < last_home_timeouts` → HOME timeout
+   - If `timeout_info.away_timeouts < last_away_timeouts` → AWAY timeout
+   - Otherwise, classified as "special play" (punt/FG/XP)
+
+### Why False Positives Occur
+
+The `DetectTimeouts` class reads timeout indicators via bright pixel analysis in configured regions:
+- **Config file**: `data/config/timeout_tracker_region.json`
+- **Home region**: (1231, 972, 30, 49) - 30x49 pixel box
+- **Away region**: (661, 973, 31, 47) - 31x47 pixel box
+
+**Problems observed in isolation testing:**
+- At 0:30 (start): Reads [False, False, False] for both teams (0 timeouts) - should be 3 each
+- At 4:30: Reads [True, True, True] for both teams (3 timeouts) - wildly inconsistent
+- Many "resets" and spurious transitions detected
+
+**Likely causes:**
+1. Region coordinates may be slightly off or need adjustment for this video
+2. Brightness threshold (200) or ratio threshold (10%) may not be optimal
+3. The timeout indicator ovals may have a different appearance than expected
+
+---
+
+## Updated Analysis (2026-01-09)
+
+### Test Methodology Improvement
+
+The initial v4 baseline test was reading timeout indicators **immediately at the 40→25 transition**. However, the timeout indicator on the scorebug updates with a **delay of 4-6 seconds** after the clock resets.
+
+Updated test methodology:
+1. Cached all 17,555 play clock readings at 2 fps
+2. Identified 55 total 40→25 transitions
+3. Compared timeout readings from 2s BEFORE to 2-6s AFTER each transition
+
+### Validation Rules Implemented
+
+A valid timeout must satisfy:
+- **Exactly one team** decreases by **exactly 1**
+- **Other team stays the same**
+- **Confidence threshold**: Both before and after readings must have confidence >= 0.5
+
+This filters out scorebug visibility issues where both teams' readings change:
+- #5 at 9:19: (2,3)→(1,1) - both changed → REJECTED
+- #11 at 29:04: (2,3)→(0,0) - both changed → REJECTED
+- #35 at 1:30:35: (3,3)→(3,1) - away changed by 2 → REJECTED
+- #45 at 1:57:55: (3,2)→(0,2) - home changed by 3 → REJECTED
+- #32 at 1:23:48: (3,3)→(3,2) with low confidence (0.487) → REJECTED
+
+---
+
+## ✅ IMPLEMENTED FIX (2026-01-09)
+
+### Final Results (Pipeline Implementation)
+
+| Metric | Value |
+|--------|-------|
+| **True Positives** | 6 |
+| **False Positives** | 0 |
+| **False Negatives** | 0 |
+| **Recall** | **100%** |
+| **Precision** | **100%** |
+
+### Detected Timeouts (All Correct)
+
+| Timestamp | Seconds | Team | Ground Truth |
+|-----------|---------|------|--------------|
+| 4:24 | 265 | HOME | ✓ Matches 4:25 |
+| 67:23 | 4044 | AWAY | ✓ Matches 67:30 |
+| 69:38 | 4178 | AWAY | ✓ Matches 69:40 |
+| 74:04 | 4444 | HOME | ✓ Matches 74:07 |
+| 76:03 | 4563 | HOME | ✓ Matches 76:06 |
+| 104:45 | 6285 | AWAY | ✓ Matches 104:54 |
+
+### Implementation Details
+
+#### Key Changes Made:
+
+1. **Delayed timeout check** (`TIMEOUT_CHECK_DELAY = 5.5s`):
+   - Store timeout reading when 40→25 transition detected
+   - Schedule check 5.5 seconds later
+   - Compare readings to detect change
+
+2. **Validation logic**:
+   - Require exactly ONE team to decrease by exactly 1
+   - Other team's count must stay the same
+   - Both readings must have confidence >= 0.5
+
+3. **Multiple entry points**:
+   - `classify_40_to_25_reset()` - handles 40→25 in PRE_SNAP state
+   - `check_possession_change()` - handles 40→25 during PLAY_IN_PROGRESS state
+   - Both now schedule delayed timeout checks
+
+4. **Merger priority fix**:
+   - Changed from `normal > special > timeout` to `normal > timeout > special`
+   - Timeout plays now have higher priority than special plays
+
+5. **Quiet time filter fix**:
+   - Only filter "special" plays in quiet time after normal plays
+   - Timeout plays can occur immediately after normal plays end
+
+#### Files Modified:
+
+- `src/tracking/play_identification_checks.py`
+- `src/tracking/state_handlers.py`
+- `src/tracking/play_state.py`
+- `src/tracking/models.py`
+- `src/tracking/play_merger.py`
+- `src/tracking/clock_reset_identifier.py`
+
+### Key Learnings
+
+1. **Scorebug timeout indicator delay**: The indicator updates 4-6 seconds AFTER the play clock resets from 40→25, not immediately
+2. **Confidence thresholds matter**: Low-confidence readings can cause false positives
+3. **Validation rules essential**: Must verify exactly one team changes by exactly 1
+4. **Multiple code paths**: 40→25 transitions can occur in both PRE_SNAP and PLAY_IN_PROGRESS states
+

scripts/cache_playclock_readings.py

@@ -0,0 +1,267 @@
+"""
+Cache all play clock readings for the OSU vs Tenn video.
+
+This script:
+1. Loads the template library
+2. Reads play clock values from fixed regions for every frame (sampled at 0.5s)
+3. Caches the results as JSON
+4. Identifies all 40→25 transitions for timeout tracker testing
+
+Usage:
+    python scripts/cache_playclock_readings.py
+"""
+
+import json
+import logging
+import sys
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+import cv2
+import numpy as np
+
+# Add src to path
+sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
+
+from readers import ReadPlayClock
+from setup import DigitTemplateLibrary
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+
+def seconds_to_timestamp(seconds: float) -> str:
+    """Convert seconds to timestamp string (H:MM:SS)."""
+    hours = int(seconds // 3600)
+    minutes = int((seconds % 3600) // 60)
+    secs = int(seconds % 60)
+    if hours > 0:
+        return f"{hours}:{minutes:02d}:{secs:02d}"
+    return f"{minutes}:{secs:02d}"
+
+
+def cache_playclock_readings(
+    video_path: str,
+    template_dir: str,
+    output_path: str,
+    playclock_coords: Tuple[int, int, int, int],
+    sample_interval: float = 0.5,
+    start_time: float = 0.0,
+    end_time: Optional[float] = None,
+) -> Dict[str, Any]:
+    """
+    Cache all play clock readings for a video.
+
+    Args:
+        video_path: Path to video file
+        template_dir: Path to digit templates directory
+        output_path: Path to save cached readings
+        playclock_coords: (x, y, width, height) absolute coordinates
+        sample_interval: Seconds between samples (default 0.5)
+        start_time: Start time in seconds
+        end_time: End time in seconds (None for full video)
+
+    Returns:
+        Dictionary with cached readings and transitions
+    """
+    # Load template library
+    logger.info("Loading template library from %s", template_dir)
+    library = DigitTemplateLibrary()
+    if not library.load(template_dir):
+        raise RuntimeError(f"Failed to load templates from {template_dir}")
+
+    coverage = library.get_coverage_status()
+    logger.info("Template coverage: %d/%d (complete: %s)", coverage["total_have"], coverage["total_needed"], coverage["is_complete"])
+
+    # Create play clock reader
+    reader = ReadPlayClock(library, region_width=playclock_coords[2], region_height=playclock_coords[3])
+
+    # Open video
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        raise RuntimeError(f"Failed to open video: {video_path}")
+
+    fps = cap.get(cv2.CAP_PROP_FPS)
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    duration = total_frames / fps
+
+    if end_time is None:
+        end_time = duration
+
+    logger.info("Video: %s", video_path)
+    logger.info("  FPS: %.2f, Total frames: %d, Duration: %s", fps, total_frames, seconds_to_timestamp(duration))
+    logger.info("  Processing: %s to %s", seconds_to_timestamp(start_time), seconds_to_timestamp(end_time))
+    logger.info("  Play clock region: (%d, %d, %d, %d)", *playclock_coords)
+
+    # Cache readings
+    readings: List[Dict[str, Any]] = []
+    current_time = start_time
+    frames_processed = 0
+    t_start = time.perf_counter()
+
+    while current_time <= end_time:
+        frame_num = int(current_time * fps)
+        cap.set(cv2.CAP_PROP_POS_FRAMES, frame_num)
+        ret, frame = cap.read()
+
+        if not ret:
+            current_time += sample_interval
+            continue
+
+        # Read play clock using fixed coordinates
+        result = reader.read_from_fixed_location(frame, playclock_coords)
+
+        reading_entry = {
+            "timestamp": current_time,
+            "frame_num": frame_num,
+            "detected": result.detected,
+            "value": result.value,
+            "confidence": result.confidence,
+            "method": result.method,
+        }
+        readings.append(reading_entry)
+
+        frames_processed += 1
+        current_time += sample_interval
+
+        # Progress log every 5 minutes of video
+        if frames_processed % int(300 / sample_interval) == 0:
+            elapsed = time.perf_counter() - t_start
+            video_minutes = current_time / 60
+            logger.info("  Processed %d frames (%.1f min), elapsed: %.1fs", frames_processed, video_minutes, elapsed)
+
+    cap.release()
+
+    elapsed = time.perf_counter() - t_start
+    logger.info("Processed %d frames in %.1fs (%.1f fps)", frames_processed, elapsed, frames_processed / elapsed)
+
+    # Identify 40→25 transitions
+    transitions = find_40_to_25_transitions(readings)
+    logger.info("Found %d potential 40→25 transitions", len(transitions))
+
+    # Build result
+    result = {
+        "video": Path(video_path).name,
+        "config": {
+            "playclock_coords": list(playclock_coords),
+            "sample_interval": sample_interval,
+            "start_time": start_time,
+            "end_time": end_time,
+        },
+        "stats": {
+            "total_readings": len(readings),
+            "detected_readings": sum(1 for r in readings if r["detected"]),
+            "processing_time": elapsed,
+        },
+        "readings": readings,
+        "transitions_40_to_25": transitions,
+    }
+
+    # Save to file
+    output_file = Path(output_path)
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+    with open(output_file, "w", encoding="utf-8") as f:
+        json.dump(result, f, indent=2)
+
+    logger.info("Saved cache to %s", output_path)
+
+    return result
+
+
+def find_40_to_25_transitions(readings: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """
+    Find all 40→25 clock transitions in the readings.
+
+    A transition is identified when:
+    1. Previous reading was 40 (or no previous reading)
+    2. Current reading is 25
+
+    Args:
+        readings: List of clock readings
+
+    Returns:
+        List of transition events with timestamps and context
+    """
+    transitions = []
+    prev_value = None
+    prev_timestamp = None
+
+    for i, reading in enumerate(readings):
+        if not reading["detected"] or reading["value"] is None:
+            continue
+
+        curr_value = reading["value"]
+        curr_timestamp = reading["timestamp"]
+
+        # Check for 40→25 transition
+        if prev_value == 40 and curr_value == 25:
+            transition = {
+                "index": i,
+                "timestamp": curr_timestamp,
+                "timestamp_str": seconds_to_timestamp(curr_timestamp),
+                "prev_timestamp": prev_timestamp,
+                "prev_value": prev_value,
+                "curr_value": curr_value,
+            }
+            transitions.append(transition)
+            logger.debug("Found 40→25 transition at %s (index %d)", seconds_to_timestamp(curr_timestamp), i)
+
+        prev_value = curr_value
+        prev_timestamp = curr_timestamp
+
+    return transitions
+
+
+def print_transitions_summary(cache_file: str) -> None:
+    """Print a summary of transitions from a cache file."""
+    with open(cache_file, "r", encoding="utf-8") as f:
+        data = json.load(f)
+
+    transitions = data.get("transitions_40_to_25", [])
+
+    print("\n" + "=" * 80)
+    print("40→25 CLOCK TRANSITIONS")
+    print("=" * 80)
+    print(f"Total transitions found: {len(transitions)}")
+    print("-" * 80)
+    print(f"{'#':<4} {'Timestamp':<12} {'Prev→Curr':<12} {'Index':<8}")
+    print("-" * 80)
+
+    for i, t in enumerate(transitions, 1):
+        print(f"{i:<4} {t['timestamp_str']:<12} {t['prev_value']}→{t['curr_value']:<8} {t['index']:<8}")
+
+    print("=" * 80)
+
+
+def main():
+    """Main function to cache play clock readings."""
+    # Configuration
+    video_path = "full_videos/OSU vs Tenn 12.21.24.mkv"
+    template_dir = "output/debug/digit_templates"
+    output_path = "output/cache/playclock_readings_full.json"
+
+    # Play clock absolute coordinates (scorebug_x + offset_x, scorebug_y + offset_y, width, height)
+    # From config: scorebug (131, 972), offset (899, 18), size (51, 28)
+    playclock_coords = (131 + 899, 972 + 18, 51, 28)
+
+    # Process full video
+    result = cache_playclock_readings(
+        video_path=video_path,
+        template_dir=template_dir,
+        output_path=output_path,
+        playclock_coords=playclock_coords,
+        sample_interval=0.5,  # Match pipeline interval
+    )
+
+    # Print summary
+    print_transitions_summary(output_path)
+
+    # Also print detection rate
+    stats = result["stats"]
+    detection_rate = stats["detected_readings"] / stats["total_readings"] * 100
+    print(f"\nDetection rate: {stats['detected_readings']}/{stats['total_readings']} ({detection_rate:.1f}%)")
+
+
+if __name__ == "__main__":
+    main()

scripts/test_timeout_at_transitions.py

@@ -0,0 +1,303 @@
+"""
+Test the timeout tracker at each 40→25 transition.
+
+This script:
+1. Loads the cached play clock readings with identified transitions
+2. For each 40→25 transition, reads the timeout indicators BEFORE and AFTER
+3. Compares the change in timeouts to determine if this was a timeout event
+4. Compares results against ground truth
+
+Ground truth timeouts:
+- 4:25 (HOME)      -> transition at ~4:26
+- 1:07:30 (AWAY)   -> transition at ~1:07:24
+- 1:09:40 (AWAY)   -> transition at ~1:09:38
+- 1:14:07 (HOME)   -> transition at ~1:14:05
+- 1:16:06 (HOME)   -> transition at ~1:16:03
+- 1:44:54 (AWAY)   -> transition at ~1:44:48
+"""
+
+import json
+import logging
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+import cv2
+import numpy as np
+
+# Add src to path
+sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
+
+from detection.timeouts import DetectTimeouts
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+
+# Ground truth timeouts (timestamp in seconds, team)
+GROUND_TRUTH_TIMEOUTS = [
+    (4 * 60 + 25, "HOME"),  # 4:25
+    (67 * 60 + 30, "AWAY"),  # 1:07:30
+    (69 * 60 + 40, "AWAY"),  # 1:09:40
+    (74 * 60 + 7, "HOME"),  # 1:14:07
+    (76 * 60 + 6, "HOME"),  # 1:16:06
+    (104 * 60 + 54, "AWAY"),  # 1:44:54
+]
+
+
+def seconds_to_timestamp(seconds: float) -> str:
+    """Convert seconds to timestamp string (H:MM:SS)."""
+    hours = int(seconds // 3600)
+    minutes = int((seconds % 3600) // 60)
+    secs = int(seconds % 60)
+    if hours > 0:
+        return f"{hours}:{minutes:02d}:{secs:02d}"
+    return f"{minutes}:{secs:02d}"
+
+
+def is_ground_truth_timeout(timestamp: float, tolerance: float = 10.0) -> Optional[str]:
+    """
+    Check if a timestamp corresponds to a ground truth timeout.
+
+    Args:
+        timestamp: Timestamp to check
+        tolerance: Seconds tolerance for matching
+
+    Returns:
+        Team name ("HOME" or "AWAY") if this is a ground truth timeout, None otherwise
+    """
+    for gt_time, team in GROUND_TRUTH_TIMEOUTS:
+        if abs(timestamp - gt_time) <= tolerance:
+            return team
+    return None
+
+
+def test_timeout_at_transitions():
+    """Test timeout detection at each 40→25 transition."""
+    # Load cached transitions
+    cache_path = Path("output/cache/playclock_readings_full.json")
+    if not cache_path.exists():
+        logger.error("Cache file not found: %s", cache_path)
+        logger.error("Run cache_playclock_readings.py first")
+        return
+
+    with open(cache_path, "r", encoding="utf-8") as f:
+        cache = json.load(f)
+
+    transitions = cache["transitions_40_to_25"]
+    logger.info("Loaded %d transitions from cache", len(transitions))
+
+    # Load timeout tracker config
+    config_path = Path("data/config/timeout_tracker_region.json")
+    if not config_path.exists():
+        logger.error("Timeout config not found: %s", config_path)
+        return
+
+    # Initialize timeout tracker
+    tracker = DetectTimeouts(config_path=str(config_path))
+    if not tracker.is_configured():
+        logger.error("Timeout tracker not configured")
+        return
+
+    # Open video
+    video_path = "full_videos/OSU vs Tenn 12.21.24.mkv"
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        logger.error("Could not open video: %s", video_path)
+        return
+
+    fps = cap.get(cv2.CAP_PROP_FPS)
+    logger.info("Video FPS: %.2f", fps)
+
+    # Test each transition
+    results: List[Dict[str, Any]] = []
+
+    # Read timeout state at video start for baseline
+    cap.set(cv2.CAP_PROP_POS_FRAMES, int(30 * fps))  # 30 seconds in
+    ret, frame = cap.read()
+    if ret:
+        baseline = tracker.read_timeouts(frame)
+        logger.info("Baseline timeouts at 30s: HOME=%d, AWAY=%d, conf=%.2f", baseline.home_timeouts, baseline.away_timeouts, baseline.confidence)
+
+    print("\n" + "=" * 100)
+    print("TIMEOUT DETECTION AT 40→25 TRANSITIONS")
+    print("=" * 100)
+    print(f"{'#':<4} {'Timestamp':<12} {'Before (H,A)':<14} {'After (H,A)':<14} {'Change':<12} {'GT Team':<10} {'Detected':<10} {'Status':<10}")
+    print("-" * 100)
+
+    for i, transition in enumerate(transitions, 1):
+        timestamp = transition["timestamp"]
+        prev_timestamp = transition.get("prev_timestamp", timestamp - 1.0)
+
+        # Read frame BEFORE transition (when clock was 40) - 2 seconds before
+        before_time = prev_timestamp - 2.0
+        frame_before = int(before_time * fps)
+        cap.set(cv2.CAP_PROP_POS_FRAMES, frame_before)
+        ret, frame = cap.read()
+        if not ret:
+            continue
+        reading_before = tracker.read_timeouts(frame)
+
+        # Read frame AFTER transition - try multiple times to catch delayed update
+        # Check at 2s, 4s, and 6s after the transition
+        reading_after = None
+        for delay in [2.0, 4.0, 6.0]:
+            after_time = timestamp + delay
+            frame_after = int(after_time * fps)
+            cap.set(cv2.CAP_PROP_POS_FRAMES, frame_after)
+            ret, frame = cap.read()
+            if not ret:
+                continue
+            reading_after = tracker.read_timeouts(frame)
+            # If we detected a change, use this reading
+            home_diff = reading_before.home_timeouts - reading_after.home_timeouts
+            away_diff = reading_before.away_timeouts - reading_after.away_timeouts
+            if home_diff > 0 or away_diff > 0:
+                break  # Found the change
+
+        if reading_after is None:
+            continue
+
+        # Determine change
+        home_change = reading_before.home_timeouts - reading_after.home_timeouts
+        away_change = reading_before.away_timeouts - reading_after.away_timeouts
+
+        # Validate: A valid timeout should show EXACTLY ONE team decreasing by 1
+        # while the other team stays the same. If both teams change, the scorebug
+        # likely disappeared (e.g., replay/commercial) and this is not a real timeout.
+        detected_team = None
+        is_valid_timeout = False
+
+        # Minimum confidence threshold for reliable readings
+        MIN_CONFIDENCE = 0.5
+
+        # Check for valid timeout pattern: one team -1, other team unchanged
+        # Also require high confidence on both readings
+        if home_change == 1 and away_change == 0:
+            if reading_before.confidence >= MIN_CONFIDENCE and reading_after.confidence >= MIN_CONFIDENCE:
+                detected_team = "HOME"
+                is_valid_timeout = True
+        elif away_change == 1 and home_change == 0:
+            if reading_before.confidence >= MIN_CONFIDENCE and reading_after.confidence >= MIN_CONFIDENCE:
+                detected_team = "AWAY"
+                is_valid_timeout = True
+        elif home_change > 0 or away_change > 0:
+            # Both teams changed, or change > 1 - likely scorebug visibility issue
+            # Log but don't detect as timeout
+            pass
+
+        # Check ground truth
+        gt_team = is_ground_truth_timeout(timestamp)
+
+        # Determine status
+        if gt_team is not None:
+            if detected_team == gt_team:
+                status = "✓ TP"  # True positive
+            elif detected_team is not None:
+                status = "✗ WRONG"  # Wrong team
+            else:
+                status = "✗ FN"  # False negative
+        else:
+            if detected_team is not None:
+                status = "✗ FP"  # False positive
+            else:
+                status = "✓ TN"  # True negative (correctly not detected)
+
+        before_str = f"({reading_before.home_timeouts},{reading_before.away_timeouts})"
+        after_str = f"({reading_after.home_timeouts},{reading_after.away_timeouts})"
+        change_str = f"H:{home_change:+d} A:{away_change:+d}"
+
+        print(f"{i:<4} {transition['timestamp_str']:<12} {before_str:<14} {after_str:<14} {change_str:<12} {gt_team or '-':<10} {detected_team or '-':<10} {status:<10}")
+
+        results.append(
+            {
+                "index": i,
+                "timestamp": timestamp,
+                "timestamp_str": transition["timestamp_str"],
+                "before_home": reading_before.home_timeouts,
+                "before_away": reading_before.away_timeouts,
+                "before_conf": reading_before.confidence,
+                "after_home": reading_after.home_timeouts,
+                "after_away": reading_after.away_timeouts,
+                "after_conf": reading_after.confidence,
+                "home_change": home_change,
+                "away_change": away_change,
+                "detected_team": detected_team,
+                "ground_truth_team": gt_team,
+                "status": status,
+            }
+        )
+
+    cap.release()
+
+    # Summary statistics
+    print("=" * 100)
+
+    tp = sum(1 for r in results if "TP" in r["status"])
+    fp = sum(1 for r in results if "FP" in r["status"])
+    fn = sum(1 for r in results if "FN" in r["status"])
+    tn = sum(1 for r in results if "TN" in r["status"])
+    wrong = sum(1 for r in results if "WRONG" in r["status"])
+
+    print(f"\nSUMMARY:")
+    print(f"  True Positives (correct timeouts):     {tp}")
+    print(f"  False Positives (spurious detections): {fp}")
+    print(f"  False Negatives (missed timeouts):     {fn}")
+    print(f"  Wrong Team:                            {wrong}")
+    print(f"  True Negatives (correct non-timeout):  {tn}")
+
+    if tp + fn > 0:
+        recall = tp / (tp + fn)
+        print(f"\n  Recall (of ground truth timeouts):     {recall:.1%} ({tp}/{tp + fn})")
+    if tp + fp > 0:
+        precision = tp / (tp + fp)
+        print(f"  Precision (of detected timeouts):      {precision:.1%} ({tp}/{tp + fp})")
+
+    # Save detailed results
+    output_path = Path("output/cache/timeout_tracker_evaluation.json")
+    with open(output_path, "w", encoding="utf-8") as f:
+        json.dump(
+            {
+                "summary": {"tp": tp, "fp": fp, "fn": fn, "tn": tn, "wrong": wrong},
+                "results": results,
+            },
+            f,
+            indent=2,
+        )
+    print(f"\nDetailed results saved to: {output_path}")
+
+
+def visualize_timeout_regions(timestamp: float):
+    """Visualize timeout regions at a specific timestamp for debugging."""
+    config_path = Path("data/config/timeout_tracker_region.json")
+    tracker = DetectTimeouts(config_path=str(config_path))
+
+    video_path = "full_videos/OSU vs Tenn 12.21.24.mkv"
+    cap = cv2.VideoCapture(video_path)
+    fps = cap.get(cv2.CAP_PROP_FPS)
+
+    frame_num = int(timestamp * fps)
+    cap.set(cv2.CAP_PROP_POS_FRAMES, frame_num)
+    ret, frame = cap.read()
+    cap.release()
+
+    if not ret:
+        logger.error("Could not read frame at %.1fs", timestamp)
+        return
+
+    reading = tracker.read_timeouts(frame)
+    vis_frame = tracker.visualize(frame, reading)
+
+    output_path = f"output/debug/timeout_tracker/vis_{int(timestamp)}.png"
+    Path(output_path).parent.mkdir(parents=True, exist_ok=True)
+    cv2.imwrite(output_path, vis_frame)
+    logger.info("Saved visualization to %s", output_path)
+    logger.info("  HOME: %d, AWAY: %d, conf: %.2f", reading.home_timeouts, reading.away_timeouts, reading.confidence)
+
+
+if __name__ == "__main__":
+    test_timeout_at_transitions()
+
+    # Optionally visualize at specific timestamps
+    # visualize_timeout_regions(265)  # Before first timeout at 4:25
+    # visualize_timeout_regions(270)  # After first timeout

src/pipeline/play_extractor.py

@@ -405,10 +405,12 @@ class PlayExtractor:
                 timeout_reading = self.timeout_tracker.read_timeouts(frame)
                 frame_result["home_timeouts"] = timeout_reading.home_timeouts
                 frame_result["away_timeouts"] = timeout_reading.away_timeouts
+                frame_result["timeout_confidence"] = timeout_reading.confidence
                 # Create TimeoutInfo for state machine clock reset classification
                 timeout_info = TimeoutInfo(
                     home_timeouts=timeout_reading.home_timeouts,
                     away_timeouts=timeout_reading.away_timeouts,
+                    confidence=timeout_reading.confidence,
                 )
 
             # Extract play clock region and run template matching immediately
@@ -724,6 +726,7 @@ class PlayExtractor:
                 timeout_info = TimeoutInfo(
                     home_timeouts=frame.get("home_timeouts"),
                     away_timeouts=frame.get("away_timeouts"),
+                    confidence=frame.get("timeout_confidence", 0.0),
                 )
             self.state_machine.update(frame["timestamp"], scorebug, clock_reading, timeout_info)
         timing["state_machine"] = time.perf_counter() - t_sm_start

src/tracking/clock_reset_identifier.py

@@ -19,6 +19,7 @@ from .models import PlayEvent
 
 logger = logging.getLogger(__name__)
 
+
 # pylint: disable=too-few-public-methods
 class ClockResetIdentifier:
     """
@@ -159,6 +160,13 @@ class ClockResetIdentifier:
 
         return False
 
+    # Minimum confidence threshold for reliable timeout readings
+    MIN_TIMEOUT_CONFIDENCE = 0.5
+
+    # Delay (seconds) after 40→25 before checking timeout indicators
+    # Must be long enough for the scorebug timeout indicator to update (typically 4-6 seconds)
+    TIMEOUT_CHECK_DELAY = 5.5
+
     def _check_timeout_change(self, frame_data: List[Dict[str, Any]], frame_idx: int) -> Optional[str]:
         """
         Check if a timeout indicator changed around the reset (Class B check).
@@ -166,6 +174,11 @@ class ClockResetIdentifier:
         Compares timeout counts before and after the reset to determine
         if a team timeout was called.
 
+        Validation rules for a valid timeout:
+        1. Exactly ONE team's count decreased by exactly 1
+        2. Other team's count stayed the same
+        3. Both before and after readings have confidence >= MIN_TIMEOUT_CONFIDENCE
+
         Args:
             frame_data: Frame data list
             frame_idx: Index of frame where 40→25 reset occurred
@@ -173,36 +186,78 @@ class ClockResetIdentifier:
         Returns:
             "home" or "away" if timeout was used, None otherwise
         """
-        # Get timeout counts before reset (look back up to 20 frames)
+        reset_timestamp: float = frame_data[frame_idx]["timestamp"]
+
+        # Get timeout counts BEFORE reset (look back for high-confidence reading)
         before_home: Optional[int] = None
         before_away: Optional[int] = None
+        before_conf: float = 0.0
 
         for j in range(frame_idx - 1, max(0, frame_idx - 20), -1):
             frame = frame_data[j]
-            if frame.get("home_timeouts") is not None:
-                before_home = frame.get("home_timeouts", 3)
-                before_away = frame.get("away_timeouts", 3)
+            conf = frame.get("timeout_confidence", 0.0)
+            if frame.get("home_timeouts") is not None and conf >= self.MIN_TIMEOUT_CONFIDENCE:
+                before_home = frame.get("home_timeouts")
+                before_away = frame.get("away_timeouts")
+                before_conf = conf
                 break
 
-        if before_home is None:
+        if before_home is None or before_away is None:
             return None
 
-        # Look forward for timeout change (up to 15 seconds)
-        frame_interval = frame_data[1]["timestamp"] - frame_data[0]["timestamp"] if len(frame_data) > 1 else 0.5
-        max_frames_forward = int(15.0 / frame_interval) if frame_interval > 0 else 30
+        # Look forward for timeout change AFTER DELAY (5.5-6 seconds after reset)
+        target_time = reset_timestamp + self.TIMEOUT_CHECK_DELAY
+        max_time = reset_timestamp + 6.0  # Search window 3-6 seconds after reset
 
-        for j in range(frame_idx, min(len(frame_data), frame_idx + max_frames_forward)):
+        after_home: Optional[int] = None
+        after_away: Optional[int] = None
+        after_conf: float = 0.0
+
+        for j in range(frame_idx + 1, len(frame_data)):
             frame = frame_data[j]
-            if frame.get("home_timeouts") is not None:
-                after_home = frame.get("home_timeouts", 3)
-                after_away = frame.get("away_timeouts", 3)
+            timestamp: float = frame["timestamp"]
+
+            # Only check after the delay period
+            if timestamp < target_time:
+                continue
+
+            # Stop if we've gone past the search window
+            if timestamp > max_time:
+                break
 
-                if after_home < before_home:
-                    return "home"
-                if after_away < before_away:
-                    return "away"
+            conf = frame.get("timeout_confidence", 0.0)
+            if frame.get("home_timeouts") is not None and conf >= self.MIN_TIMEOUT_CONFIDENCE:
+                after_home = frame.get("home_timeouts")
+                after_away = frame.get("away_timeouts")
+                after_conf = conf
+                break
+
+        if after_home is None or after_away is None:
+            return None
 
-        return None
+        # Validate timeout pattern: EXACTLY one team -1, other unchanged
+        home_change = before_home - after_home  # positive = decrease
+        away_change = before_away - after_away  # positive = decrease
+
+        timeout_team = None
+        if home_change == 1 and away_change == 0:
+            timeout_team = "home"
+        elif away_change == 1 and home_change == 0:
+            timeout_team = "away"
+
+        if timeout_team:
+            logger.debug(
+                "Timeout detected: %s team (before=(%d,%d) conf=%.2f, after=(%d,%d) conf=%.2f)",
+                timeout_team,
+                before_home,
+                before_away,
+                before_conf,
+                after_home,
+                after_away,
+                after_conf,
+            )
+
+        return timeout_team
 
     def _find_play_end(self, frame_data: List[Dict[str, Any]], frame_idx: int, max_duration: float) -> float:
         """

src/tracking/models.py

@@ -55,6 +55,7 @@ class TimeoutInfo(BaseModel):
 
     home_timeouts: Optional[int] = Field(None, description="Number of home team timeouts remaining")
     away_timeouts: Optional[int] = Field(None, description="Number of away team timeouts remaining")
+    confidence: float = Field(0.0, description="Confidence of the timeout reading")
 
 
 class ClockResetStats(BaseModel):
@@ -97,4 +98,13 @@ class PlayTrackingState(BaseModel):
     # Timeout tracking for clock reset classification
     last_home_timeouts: Optional[int] = Field(None, description="Last observed home team timeouts")
     last_away_timeouts: Optional[int] = Field(None, description="Last observed away team timeouts")
+    last_timeout_confidence: float = Field(0.0, description="Confidence of last timeout reading")
     clock_reset_stats: ClockResetStats = Field(default_factory=ClockResetStats, description="Statistics about clock reset classifications")
+
+    # Pending timeout resolution (for delayed timeout detection)
+    # When 40→25 detected, we store the "before" state and check again after delay
+    pending_timeout_check_time: Optional[float] = Field(None, description="Timestamp when we should resolve pending timeout check")
+    pending_timeout_transition_time: Optional[float] = Field(None, description="Timestamp when the 40→25 transition occurred")
+    timeout_home_at_40: Optional[int] = Field(None, description="Home timeouts when clock was at 40 (before 40→25)")
+    timeout_away_at_40: Optional[int] = Field(None, description="Away timeouts when clock was at 40 (before 40→25)")
+    timeout_conf_at_40: float = Field(0.0, description="Timeout confidence when clock was at 40")

src/tracking/play_identification_checks.py

@@ -46,10 +46,20 @@ class PlayIdentificationChecks:
         self.config = config
         self.lifecycle = lifecycle
 
+    # Minimum confidence for timeout readings to be considered valid
+    MIN_TIMEOUT_CONFIDENCE = 0.5
+
+    # Delay (seconds) after 40→25 transition before checking timeout indicators
+    # Must be long enough for the scorebug timeout indicator to update (typically 4-6 seconds)
+    TIMEOUT_CHECK_DELAY = 5.5
+
     def check_timeout_change(self, timeout_info: Optional[TimeoutInfo] = None) -> Optional[str]:
         """
         Check if a timeout indicator changed, indicating a team timeout.
 
+        DEPRECATED: This immediate check is no longer used for 40→25 classification.
+        Use check_pending_timeout_resolution() for delayed timeout detection.
+
         Args:
             timeout_info: Current timeout information
 
@@ -70,6 +80,113 @@ class PlayIdentificationChecks:
 
         return None
 
+    def check_pending_timeout_resolution(self, timestamp: float, timeout_info: TimeoutInfo) -> None:
+        """
+        Check if it's time to resolve a pending timeout classification.
+
+        Called every frame after 40→25 transition to check if enough time has passed
+        and if the timeout indicators have changed (indicating a real timeout vs special play).
+
+        Validation rules for a valid timeout:
+        1. Exactly ONE team's count decreased by exactly 1
+        2. Other team's count stayed the same
+        3. Both before and after readings have confidence >= MIN_TIMEOUT_CONFIDENCE
+
+        Args:
+            timestamp: Current video timestamp
+            timeout_info: Current timeout indicator information
+        """
+        # Check if we have a pending timeout to resolve
+        if self._state.pending_timeout_check_time is None:
+            return
+
+        # Not yet time to check
+        if timestamp < self._state.pending_timeout_check_time:
+            return
+
+        # Time to resolve - compare current reading with "at 40" reading
+        before_home = self._state.timeout_home_at_40
+        before_away = self._state.timeout_away_at_40
+        before_conf = self._state.timeout_conf_at_40
+        after_home = timeout_info.home_timeouts
+        after_away = timeout_info.away_timeouts
+        after_conf = timeout_info.confidence
+
+        # Get transition time before clearing (needed for play lookup)
+        transition_time = self._state.pending_timeout_transition_time
+
+        # Clear pending state
+        self._state.pending_timeout_check_time = None
+        self._state.timeout_home_at_40 = None
+        self._state.timeout_away_at_40 = None
+        self._state.timeout_conf_at_40 = 0.0
+        # Note: pending_timeout_transition_time is cleared in the confirmation logic below
+
+        # Validate we have all needed values
+        if before_home is None or before_away is None or after_home is None or after_away is None:
+            logger.debug("Pending timeout check skipped: missing timeout values")
+            return
+
+        # Check confidence threshold
+        if before_conf < self.MIN_TIMEOUT_CONFIDENCE or after_conf < self.MIN_TIMEOUT_CONFIDENCE:
+            logger.debug(
+                "Pending timeout check: low confidence (before=%.2f, after=%.2f), keeping as special play",
+                before_conf,
+                after_conf,
+            )
+            return
+
+        # Calculate changes
+        home_change = before_home - after_home
+        away_change = before_away - after_away
+
+        # Validate timeout pattern: exactly one team -1, other unchanged
+        timeout_team = None
+        if home_change == 1 and away_change == 0:
+            timeout_team = "home"
+        elif away_change == 1 and home_change == 0:
+            timeout_team = "away"
+
+        # Clear transition time state
+        self._state.pending_timeout_transition_time = None
+
+        if timeout_team:
+            # Valid timeout detected - reclassify the play associated with this timeout
+            logger.info(
+                "Delayed timeout detection: %s team timeout confirmed at %.1fs (before=(%d,%d) after=(%d,%d))",
+                timeout_team.upper(),
+                timestamp,
+                before_home,
+                before_away,
+                after_home,
+                after_away,
+            )
+            # Update the current play's classification
+            self._state.current_play_type = "timeout"
+
+            # Find the play that corresponds to this timeout by matching transition timestamp
+            if self._state.plays and transition_time is not None:
+                # Find play whose start or end time is close to the transition
+                for i, play in enumerate(self._state.plays):
+                    # Check if this play's timing matches the transition
+                    if play.play_type == "special" and abs(play.start_time - transition_time) < 10:
+                        # Update this play to be a timeout
+                        self._state.plays[i] = play.model_copy(update={"start_method": f"timeout_{timeout_team}", "play_type": "timeout"})
+                        logger.debug("Reclassified play #%d at %.1fs as %s timeout", play.play_number, play.start_time, timeout_team.upper())
+                        break
+            elif self._state.current_play_start_time is not None:
+                # If we're currently in a play that started as special, update it
+                pass  # Will be classified correctly when play ends
+
+            self._state.clock_reset_stats.timeout += 1
+            self._state.clock_reset_stats.special -= 1  # Undo the special count
+        else:
+            logger.debug(
+                "Pending timeout check: no valid timeout pattern (home_change=%d, away_change=%d), keeping as special play",
+                home_change,
+                away_change,
+            )
+
     def check_play_timeout(self, timestamp: float, clock_value: int) -> Optional[PlayEvent]:
         """Check if play duration has exceeded maximum allowed time.
 
@@ -115,18 +232,25 @@ class PlayIdentificationChecks:
         )
         self._state.countdown_history = []
 
-    def check_possession_change(self, timestamp: float, clock_value: int) -> None:
+    def check_possession_change(self, timestamp: float, clock_value: int, timeout_info: Optional[TimeoutInfo] = None) -> bool:
         """Check for rapid 40→25 transition indicating possession change during play.
 
         This happens during punts, kickoffs, and after XPs/FGs. The play continues
         (e.g., punt return in progress) - we don't end the play here.
 
+        Also schedules a delayed timeout check, as timeouts can trigger 40→25
+        transitions during plays (e.g., timeout called during an ongoing play).
+
         Args:
             timestamp: Current video timestamp
             clock_value: Current clock value
+            timeout_info: Optional timeout indicator information for delayed timeout check
+
+        Returns:
+            True if transition was handled, False otherwise (caller should continue checking)
         """
         if clock_value != 25 or self._state.first_40_timestamp is None:
-            return  # Not a 40→25 transition
+            return False  # Not a 40→25 transition
 
         time_at_40 = timestamp - self._state.first_40_timestamp
         max_time_for_possession_change = 5.0
@@ -144,6 +268,26 @@ class PlayIdentificationChecks:
             self._state.first_40_timestamp = None
             self._state.countdown_history = []
 
+            # Schedule delayed timeout check (same as classify_40_to_25_reset)
+            # This allows us to detect timeouts called during mid-play transitions
+            if timeout_info is not None:
+                self._state.timeout_home_at_40 = timeout_info.home_timeouts
+                self._state.timeout_away_at_40 = timeout_info.away_timeouts
+                self._state.timeout_conf_at_40 = timeout_info.confidence
+                self._state.pending_timeout_check_time = timestamp + self.TIMEOUT_CHECK_DELAY
+                self._state.pending_timeout_transition_time = timestamp  # Store when the 40→25 occurred
+                self._state.clock_reset_stats.total += 1
+                self._state.clock_reset_stats.special += 1  # Initially classified as special
+                logger.debug(
+                    "Scheduled timeout check at %.1fs for mid-play 40→25 (timeouts: H=%s, A=%s)",
+                    self._state.pending_timeout_check_time,
+                    timeout_info.home_timeouts,
+                    timeout_info.away_timeouts,
+                )
+            return True  # Transition was handled, skip subsequent checks
+
+        return False  # Not a valid possession change, continue with other checks
+
     def check_abnormal_clock_drop(self, timestamp: float, clock_value: int) -> Optional[PlayEvent]:
         """Check for abnormal clock drop on first reading after 40.
 
@@ -161,6 +305,11 @@ class PlayIdentificationChecks:
         if len(self._state.countdown_history) != 0:
             return None  # Not the first reading after 40
 
+        # If already in special play mode (clock base = 25), skip this check
+        # This prevents false triggers after check_possession_change handles a 40→25 transition
+        if self._state.current_play_clock_base == 25:
+            return None
+
         clock_drop = 40 - clock_value
         max_normal_drop = 5
         if clock_drop <= max_normal_drop:
@@ -242,14 +391,20 @@ class PlayIdentificationChecks:
         """
         Classify a 40→25 clock reset and handle appropriately.
 
-        Classification:
+        Classification (with delayed timeout detection):
         - Class A (weird_clock): Will be handled by checking if 25 counts down immediately
           (identified later via abnormal clock drop check)
-        - Class B (timeout): Timeout indicator changed → tracked as timeout play
-        - Class C (special): Neither A nor B → special play (punt/FG/XP)
+        - Class B (timeout): Timeout indicator changes AFTER 3-4 seconds → tracked as timeout play
+        - Class C (special): No timeout change → special play (punt/FG/XP)
+
+        The timeout check is DELAYED because the scorebug's timeout indicator updates
+        2-6 seconds after the clock resets, not immediately.
 
-        For now, we check for timeout change. If no timeout, treat as special play.
-        The weird_clock case will naturally be filtered when 25 starts counting down.
+        Strategy:
+        1. Store current timeout reading as "at 40" reference
+        2. Start play as "special" initially
+        3. Set pending check time (timestamp + TIMEOUT_CHECK_DELAY)
+        4. check_pending_timeout_resolution() will reclassify if timeout detected
 
         Args:
             timestamp: Current timestamp
@@ -257,20 +412,28 @@ class PlayIdentificationChecks:
         """
         self._state.clock_reset_stats.total += 1
 
-        # Check for timeout change (Class B)
-        timeout_team = self.check_timeout_change(timeout_info)
-
-        if timeout_team:
-            # Class B: Team timeout identified
-            self._state.clock_reset_stats.timeout += 1
-            logger.info("Clock reset 40→25 at %.1fs classified as TIMEOUT (%s team)", timestamp, timeout_team)
-            self._state.current_play_clock_base = 25
-            self._state.current_play_type = "timeout"
-            self.lifecycle.start_play(timestamp, f"timeout_{timeout_team}", 40)
+        # Store current timeout state as "before" reference for delayed check
+        if timeout_info is not None:
+            self._state.timeout_home_at_40 = timeout_info.home_timeouts
+            self._state.timeout_away_at_40 = timeout_info.away_timeouts
+            self._state.timeout_conf_at_40 = timeout_info.confidence
+            # Schedule delayed timeout check
+            self._state.pending_timeout_check_time = timestamp + self.TIMEOUT_CHECK_DELAY
+            self._state.pending_timeout_transition_time = timestamp  # Store when the 40→25 occurred
+            logger.debug(
+                "Scheduled timeout check at %.1fs (current timeouts: H=%s, A=%s, conf=%.2f)",
+                self._state.pending_timeout_check_time,
+                timeout_info.home_timeouts,
+                timeout_info.away_timeouts,
+                timeout_info.confidence,
+            )
         else:
-            # Class C: Special play (punt/FG/XP) - or potentially Class A (will be filtered later)
-            self._state.clock_reset_stats.special += 1
-            logger.info("Clock reset 40→25 at %.1fs classified as SPECIAL play", timestamp)
-            self._state.current_play_clock_base = 25
-            self._state.current_play_type = "special"
-            self.lifecycle.start_play(timestamp, "clock_reset_special", 40)
+            # No timeout info available, can't do delayed check
+            self._state.pending_timeout_check_time = None
+
+        # Start as special play initially - may be reclassified as timeout later
+        self._state.clock_reset_stats.special += 1
+        logger.info("Clock reset 40→25 at %.1fs classified as SPECIAL play (pending timeout check)", timestamp)
+        self._state.current_play_clock_base = 25
+        self._state.current_play_type = "special"
+        self.lifecycle.start_play(timestamp, "clock_reset_special", 40)

src/tracking/play_merger.py

@@ -95,8 +95,8 @@ class PlayMerger:  # pylint: disable=too-few-public-methods
 
             if is_overlapping or is_close:
                 # Same event detected twice - keep the better one
-                # Priority: normal > special > timeout (normal plays are most reliable)
-                type_priority = {"normal": 3, "special": 2, "timeout": 1}
+                # Priority: normal > timeout > special (timeout is a more specific classification than special)
+                type_priority = {"normal": 3, "timeout": 2, "special": 1}
                 last_priority = type_priority.get(last.play_type, 0)
                 play_priority = type_priority.get(play.play_type, 0)
 
@@ -114,9 +114,12 @@ class PlayMerger:  # pylint: disable=too-few-public-methods
         """
         Apply quiet time filter after normal plays.
 
-        After a normal play ends, no new special/timeout plays can start for quiet_time seconds.
+        After a normal play ends, no new SPECIAL plays can start for quiet_time seconds.
         This filters out false positives from penalties during plays (false starts, delay of game, etc.).
 
+        NOTE: Timeout plays are NOT filtered because timeouts can legitimately be called
+        immediately after a play ends.
+
         Args:
             plays: List of plays sorted by start time
 
@@ -131,8 +134,9 @@ class PlayMerger:  # pylint: disable=too-few-public-methods
 
         for play in plays:
             # Check if this play starts during quiet time after a normal play
-            if play.start_time < last_normal_end + self.quiet_time and play.play_type != "normal":
-                # This non-normal play starts during quiet time - filter it out
+            # Only filter "special" plays, NOT timeout plays (timeouts can occur right after plays)
+            if play.start_time < last_normal_end + self.quiet_time and play.play_type == "special":
+                # This special play starts during quiet time - filter it out
                 time_since_normal = play.start_time - last_normal_end
                 logger.debug(
                     "Quiet time filter: Removing %s play at %.1fs (%.1fs after normal play ended)",

src/tracking/play_state.py

@@ -108,6 +108,10 @@ class TrackPlayState:
                 self._state.last_home_timeouts = timeout_info.home_timeouts
             if timeout_info.away_timeouts is not None:
                 self._state.last_away_timeouts = timeout_info.away_timeouts
+            self._state.last_timeout_confidence = timeout_info.confidence
+
+            # Check for pending timeout resolution (delayed timeout detection)
+            self._identification.check_pending_timeout_resolution(timestamp, timeout_info)
 
         # Handle scorebug presence/absence
         if not scorebug.detected:
@@ -152,7 +156,7 @@ class TrackPlayState:
 
         elif self._state.state == PlayState.PLAY_IN_PROGRESS:
             # Play is live, watching for it to end (clock restarts)
-            completed_play = self._handlers.handle_play_in_progress(timestamp, clock_value)
+            completed_play = self._handlers.handle_play_in_progress(timestamp, clock_value, timeout_info)
 
         elif self._state.state == PlayState.POST_PLAY:
             # Play ended, transitioning back to PRE_SNAP

src/tracking/state_handlers.py

@@ -121,7 +121,7 @@ class StateHandlers:
         if self._state.last_clock_value is None:
             self._state.last_clock_value = clock_value
             self._state.clock_stable_count = 1
-            return None # exit early if no last clock value
+            return None  # exit early if no last clock value
 
         # Check for clock reset to 40 (indicates ball was snapped for normal play)
         # Require a significant jump in clock value to avoid false positives from OCR noise
@@ -177,7 +177,7 @@ class StateHandlers:
         # The clock_reset identification (going to 40 or 25) is the reliable method
         return None
 
-    def handle_play_in_progress(self, timestamp: float, clock_value: int) -> Optional[PlayEvent]:
+    def handle_play_in_progress(self, timestamp: float, clock_value: int, timeout_info: Optional[TimeoutInfo] = None) -> Optional[PlayEvent]:
         """Handle clock reading during PLAY_IN_PROGRESS state.
 
         Delegates to identification checks for each scenario.
@@ -185,6 +185,7 @@ class StateHandlers:
         Args:
             timestamp: Current video timestamp
             clock_value: Current clock value
+            timeout_info: Optional timeout indicator information
 
         Returns:
             PlayEvent if play ended, None otherwise
@@ -203,8 +204,10 @@ class StateHandlers:
             return None
 
         # Check for possession change (40→25 transition)
-        # Note: This function only updates state, never returns a PlayEvent
-        self.identification.check_possession_change(timestamp, clock_value)
+        # Also schedules delayed timeout check if 40→25 detected
+        # Returns True if transition was handled (skip subsequent checks)
+        if self.identification.check_possession_change(timestamp, clock_value, timeout_info):
+            return None  # Transition handled, don't run abnormal clock drop check
 
         # Check for abnormal clock drop (first reading after 40)
         result = self.identification.check_abnormal_clock_drop(timestamp, clock_value)