feat(agent): temporal video dedup — drop near-duplicate frames before the GPU

Near-static videos are the dominant GPU load: sampled into up to 64 frames, each
re-runs the whole detect→CCIP→SigLIP chain on ~identical content. Add a CPU
perceptual-hash frame dedup upstream of the GPU so the redundant frames are never
processed at all (not just their embeds).

- media.dedupe_frames() + _dhash(): 8×8 difference-hash (64-bit) per frame; greedy
  keep — a frame survives only if its hash differs from every kept frame by
  >= min_distance bits (Hamming). A static run collapses to one frame; genuinely
  distinct scenes all survive. Order + frame_time preserved.
- Called in worker._download_decode right after sample_frames, so it runs in the
  decode stage on the downloader thread (CPU) — the GPU consumers only ever see
  deduped frames, and buffered video items shrink (less RAM too).
- Env-tunable FRAME_DEDUPE_DISTANCE (default 8; higher keeps more frames for brief
  localized changes an 8×8 hash can miss; 0 disables). Logs `video frames N→M`
  when it drops any, so video load reduction is visible.

Complements the spatial per-frame crop dedup (2026-07-01.2); this is the temporal
axis. Build marker 2026-07-01.3.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Ttrj5P7upUTueSfoJcxEqa

agent/fc_agent/worker.py

@@ -467,6 +467,15 @@ class Worker:
                 data, job.get("frame_interval_seconds", 4.0),
                 job.get("max_frames", 64),
             ) or [(None, media.load_image(data))]
+            # Temporal dedup: a near-static video sampled into many frames re-runs
+            # the whole detect+embed chain on ~identical frames. Drop near-dup
+            # frames HERE (decode stage, CPU) so the GPU never sees them.
+            if len(frames) > 1 and self.cfg.frame_dedupe_distance > 0:
+                kept = media.dedupe_frames(frames, self.cfg.frame_dedupe_distance)
+                if len(kept) < len(frames):
+                    log.info("job %s: video frames %d→%d (near-dup dedup)",
+                             job.get("job_id"), len(frames), len(kept))
+                frames = kept
         else:
             frames = [(None, media.load_image(data))]
         self._record("decode", time.monotonic() - _t)