@lemoncat7/dsh-partner 2.8.1 → 2.8.3

package/resources/skills/video-recap-production/upstream/skills/video-understanding/scripts/timeline_fusion.py

@@ -0,0 +1,108 @@
+"""Fuse scenes, ASR, and quiet windows for narration planning."""
+
+from lib import CONFIG
+from agent_text import _overlap_seconds, _recommended_char_budget
+from narration_lint import _validate_narration_budget
+
+
+def _quiet_windows(silence_periods):
+    return [qp for qp in silence_periods if not qp["has_speech"]]
+
+
+def _align_narration_to_quiet(narration, scenes_analysis, silence_periods):
+    """Recompute overlaps_speech from real quiet windows; keep the agent's timing.
+
+    The dense continuous-bed design places narration ON the pictured beat over a
+    ducked original bed, so segments are never relocated into silence gaps. Only
+    the overlaps_speech flag that the ducking stage consumes is corrected, leaving
+    the agent's start/end (and text) intact.
+
+    Budget/dedup runs FIRST so a dedup-merged beat's overlaps_speech reflects its
+    extended timing, not its original shorter span.
+    """
+    aligned = _validate_narration_budget(narration, scenes_analysis)
+    quiet_windows = _quiet_windows(silence_periods)
+    quiet_ratio_min = CONFIG["quiet_overlap_min_ratio"]
+    for n in aligned:
+        seg_dur = n["end"] - n["start"]
+        quiet_overlap = sum(
+            _overlap_seconds(n["start"], n["end"], qw["start"], qw["end"])
+            for qw in quiet_windows
+        )
+        n["overlaps_speech"] = quiet_overlap < max(0.3, seg_dur * quiet_ratio_min)
+    return aligned
+
+
+def _scene_asr_lines(asr_result, scene):
+    lines = []
+    for seg in asr_result:
+        if scene["start"] < seg["end"] and scene["end"] > seg["start"] and seg["text"]:
+            lines.append(f"    [{seg['start']:.1f}-{seg['end']:.1f}] {seg['text']}")
+    return lines
+
+
+def _quiet_windows_for_scene(silence_periods, scene):
+    windows = []
+    for qp in _quiet_windows(silence_periods):
+        if qp["start"] < scene["end"] and qp["end"] > scene["start"]:
+            start = max(qp["start"], scene["start"])
+            end = min(qp["end"], scene["end"])
+            if end > start:
+                windows.append((start, end))
+    return windows
+
+
+def _build_timeline_fusion(scenes, asr_segments, silence_periods):
+    """Fuse VLM scenes, ASR dialogue and quiet narration slots on one timeline."""
+    fusion = []
+    quiet_windows = _quiet_windows(silence_periods)
+    for scene in scenes:
+        start, end = scene["start"], scene["end"]
+        dialogue_segments = []
+        dialogue_overlap = 0.0
+        for seg in asr_segments:
+            overlap = _overlap_seconds(start, end, seg["start"], seg["end"])
+            if overlap <= 0:
+                continue
+            dialogue_overlap += overlap
+            dialogue_segments.append(
+                {
+                    "start": round(seg["start"], 2),
+                    "end": round(seg["end"], 2),
+                    "overlap_seconds": round(overlap, 2),
+                    "text": seg["text"],
+                }
+            )
+
+        narration_slots = []
+        for window in quiet_windows:
+            overlap = _overlap_seconds(start, end, window["start"], window["end"])
+            if overlap <= 0:
+                continue
+            slot_start = max(start, window["start"])
+            slot_end = min(end, window["end"])
+            narration_slots.append(
+                {
+                    "start": round(slot_start, 2),
+                    "end": round(slot_end, 2),
+                    "duration": round(slot_end - slot_start, 2),
+                    "char_budget": _recommended_char_budget(slot_start, slot_end),
+                }
+            )
+
+        fusion.append(
+            {
+                "scene_id": scene["scene_id"],
+                "time_range": [round(start, 2), round(end, 2)],
+                "visual_description": scene["description"],
+                "depth_analysis": scene.get("depth_analysis", ""),
+                "frame_facts": scene.get("frame_facts", {}),
+                "dialogue_segments": dialogue_segments,
+                "dialogue_overlap_seconds": round(dialogue_overlap, 2),
+                "narration_slots": narration_slots,
+                "recommended_mode": "quiet-slot"
+                if narration_slots and dialogue_overlap < (end - start) * 0.4
+                else "ducked-bed",
+            }
+        )
+    return fusion

package/resources/skills/video-recap-production/upstream/skills/video-understanding/scripts/understand.py

@@ -0,0 +1,9 @@
+#!/usr/bin/env python3
+"""CLI entrypoint for the self-contained video-understanding skill."""
+
+from understanding_runner import main
+
+__all__ = ["main"]
+
+if __name__ == "__main__":
+    main()

package/resources/skills/video-recap-production/upstream/skills/video-understanding/scripts/understanding_brief.py

@@ -0,0 +1,190 @@
+"""Format research context and rebuild briefs from cached analysis."""
+
+import json
+
+from pathlib import Path
+
+from lib import CONFIG, log, load_background_research
+from asr_timing_evidence import asr_evidence_summary_for_brief
+
+
+from detect import detect_speech_boundary_anchors
+
+
+from brief import build_agent_brief, assess_understanding_substrate
+
+
+from understanding_cache import _load_json, _merge_overview_into_scenes
+from understanding_storyboard import (
+    _generate_edited_storyboard,
+    _generate_source_storyboard,
+    _prepend_storyboard_brief_header,
+)
+
+
+def _clip_text(text, limit):
+    value = " ".join(str(text or "").split()).strip()
+    return value[:limit]
+
+
+def _research_context(work_dir):
+    """Fold background_research.json into a compact context string for the VLM prompt.
+
+    The agent does story research first (per references/research-guide.md) and writes
+    work_dir/background_research.json; this surfaces synopsis, named characters,
+    relationships, plot arcs, and cultural notes so scene VLM analysis can name people
+    and read scenes with plot knowledge instead of labelling everyone "黑衣男子".
+    Returns "" when no usable research file is present, so behaviour is unchanged.
+    """
+    data = load_background_research(work_dir)
+    if not data:
+        return ""
+    parts = []
+    for key in ("synopsis", "episode_context", "worldbuilding"):
+        val = _clip_text(data.get(key), 320)
+        if val:
+            parts.append(val)
+    chars = data.get("characters")
+    if isinstance(chars, dict) and chars:
+        named = "；".join(
+            f"{_clip_text(name, 40)}（{_clip_text(desc, 120)}）"
+            for name, desc in list(chars.items())[:12]
+            if _clip_text(name, 40)
+        )
+        if named:
+            parts.append("主要人物：" + named)
+    details = data.get("character_details")
+    if isinstance(details, dict) and details:
+        detail_lines = []
+        for name, info in list(details.items())[:8]:
+            if not isinstance(info, dict):
+                continue
+            bits = []
+            aliases = info.get("aliases")
+            if isinstance(aliases, list) and aliases:
+                clean_aliases = [_clip_text(alias, 30) for alias in aliases[:3]]
+                clean_aliases = [alias for alias in clean_aliases if alias]
+                if clean_aliases:
+                    bits.append("别名" + "/".join(clean_aliases))
+            role = _clip_text(info.get("role"), 60)
+            if role:
+                bits.append(role)
+            rels = info.get("relationships")
+            if isinstance(rels, list) and rels:
+                clean_rels = [_clip_text(rel, 60) for rel in rels[:3]]
+                bits.extend(rel for rel in clean_rels if rel)
+            clean_name = _clip_text(name, 40)
+            if clean_name and bits:
+                detail_lines.append(f"{clean_name}（{'；'.join(bits)}）")
+        if detail_lines:
+            parts.append("人物关系：" + "；".join(detail_lines))
+    arcs = data.get("plot_arcs")
+    if isinstance(arcs, list) and arcs:
+        arc_lines = []
+        for arc in arcs[:6]:
+            if not isinstance(arc, dict):
+                val = _clip_text(arc, 120)
+                if val:
+                    arc_lines.append(val)
+                continue
+            name = _clip_text(arc.get("name"), 50)
+            desc = _clip_text(arc.get("description"), 120)
+            status = _clip_text(arc.get("status"), 30)
+            if name or desc:
+                tail = f"[{status}]" if status else ""
+                arc_lines.append(f"{name}：{desc}{tail}".strip("："))
+        if arc_lines:
+            parts.append("剧情线：" + "；".join(arc_lines))
+    notes = data.get("cultural_notes")
+    if isinstance(notes, list) and notes:
+        note_lines = []
+        for note in notes[:4]:
+            if not isinstance(note, dict):
+                val = _clip_text(note, 100)
+                if val:
+                    note_lines.append(val)
+                continue
+            item = _clip_text(note.get("item"), 50)
+            expl = _clip_text(note.get("explanation"), 100)
+            if item or expl:
+                note_lines.append(f"{item}：{expl}".strip("："))
+        if note_lines:
+            parts.append("背景注释：" + "；".join(note_lines))
+    return " ".join(parts).strip()[:1200]
+
+
+def _load_understanding_artifacts_for_brief(work_dir):
+    """Load existing analysis artifacts for a brief-only regeneration pass.
+
+    Material-library restores are allowed to reuse expensive analysis artifacts,
+    but cut pass 2 must still rebuild `agent_narration_brief.md` against the
+    rendered OUTPUT timeline. This helper deliberately performs no extraction,
+    ASR, VLM, or external API calls; it only reads already-present JSON. An absent
+    artifact contributes [] (the brief documents the thin substrate); a corrupt one raises.
+    """
+    work_dir = Path(work_dir)
+
+    def _own(name):
+        path = work_dir / name
+        return _load_json(path) if path.exists() else []
+
+    return _own("vlm_analysis.json"), _own("asr_result.json"), _own("silence_periods.json")
+
+
+def _write_brief_from_existing_artifacts(video, work_dir, args, video_duration):
+    """Regenerate only the agent brief/timeline-fusion from existing artifacts."""
+    scenes, asr_result, silence_periods = _load_understanding_artifacts_for_brief(
+        work_dir
+    )
+    if not (Path(work_dir) / "speech_boundary_anchors.json").exists():
+        detect_speech_boundary_anchors(work_dir, asr_result)
+    overview_path = Path(work_dir) / "mimo_video_overview.json"
+    if CONFIG["mimo_video_overview"]:
+        scenes = _merge_overview_into_scenes(scenes, overview_path)
+
+    source_storyboard = None
+    edited_storyboard = None
+    scenes_json = Path(work_dir) / "scenes.json"
+    if scenes_json.exists():
+        source_storyboard = _generate_source_storyboard(
+            work_dir, Path(video), scenes, scenes_json, force=False
+        )
+    edited_storyboard = _generate_edited_storyboard(work_dir, video, force=False)
+    cut_mode = (Path(work_dir) / "clip_plan_validated.json").exists()
+
+    substrate = assess_understanding_substrate(scenes, asr_result)
+    if substrate["level"] != "rich":
+        banner = "理解素材为空" if substrate["level"] == "empty" else "理解素材偏薄"
+        log(
+            f"⚠️  {banner}：ASR {substrate['asr_chars']} 字 | 场景 {substrate['scene_count']} | "
+            f"带 frame_facts 的场景 {substrate['scenes_with_frame_facts']} | 平均画面描述 {substrate['avg_description_len']} 字"
+        )
+    brief_path = build_agent_brief(
+        scenes,
+        asr_result,
+        silence_periods,
+        video_duration,
+        work_dir,
+        args.style,
+        mimo_overview_enabled=CONFIG["mimo_video_overview"],
+        mimo_overview_video_path=video,
+        asr_evidence=asr_evidence_summary_for_brief(work_dir, video),
+    )
+    _prepend_storyboard_brief_header(
+        brief_path, source_storyboard, edited_storyboard, cut_mode=cut_mode
+    )
+    log("=" * 50)
+    log(f"brief-only 完成。写作 brief: {brief_path}")
+    print(
+        json.dumps(
+            {
+                "status": "brief_only",
+                "work_dir": str(work_dir),
+                "brief": str(brief_path),
+                "substrate": substrate["level"],
+                "scenes": len(scenes),
+                "asr_segments": len(asr_result),
+            },
+            ensure_ascii=False,
+        )
+    )

package/resources/skills/video-recap-production/upstream/skills/video-understanding/scripts/understanding_cache.py

@@ -0,0 +1,345 @@
+"""Own understanding-stage cache keys, provenance, and statuses."""
+
+import json
+
+from pathlib import Path
+
+from asr_timing_evidence import EVIDENCE_FILENAME, validate_asr_timing_evidence
+from extract import FRAME_TIME_CONVENTION_VERSION
+from lib import CONFIG, log, file_identity, load_prompt
+
+
+from vlm import (
+    _is_mimo_chunk_usable,
+)
+
+
+def _fresh(out, *inputs):
+    out = Path(out)
+    if not out.exists():
+        return False
+    ins = [Path(p) for p in inputs if p and Path(p).exists()]
+    if not ins:
+        return out.stat().st_size > 0
+    return out.stat().st_mtime >= max(p.stat().st_mtime for p in ins)
+
+
+def _artifact_meta_path(artifact_path):
+    artifact_path = Path(artifact_path)
+    return artifact_path.with_name(f"{artifact_path.name}.meta.json")
+
+
+def _load_json(path):
+    return json.loads(Path(path).read_text(encoding="utf-8"))
+
+
+def _video_input(video_path):
+    """The source video as a cache input: resolved path plus {size, mtime_ns}, so two
+    different files written in the same timestamp tick never share a stage output."""
+    return {"path": str(Path(video_path).resolve()), **file_identity(video_path)}
+
+
+def _artifact_identity(path):
+    """{size, mtime_ns} of an input artifact, or None when it does not exist."""
+    path = Path(path)
+    return file_identity(path) if path.exists() else None
+
+
+def _stage_cache_valid(artifact_path, expected_meta):
+    """A stage output is reusable when it exists, is non-empty, its sidecar equals the
+    expected inputs/settings dict, and the output itself is the one the sidecar recorded."""
+    artifact_path = Path(artifact_path)
+    if not artifact_path.exists() or artifact_path.stat().st_size == 0:
+        return False
+    meta_path = _artifact_meta_path(artifact_path)
+    if not meta_path.exists():
+        return False
+    try:
+        meta = _load_json(meta_path)
+    except (OSError, ValueError, TypeError):
+        return False
+    if not isinstance(meta, dict) or meta.get("artifact") != file_identity(artifact_path):
+        return False
+    expected = dict(expected_meta)
+    expected["artifact"] = meta["artifact"]
+    return meta == expected
+
+
+def _write_stage_meta(artifact_path, meta):
+    meta_path = _artifact_meta_path(artifact_path)
+    payload = dict(meta)
+    payload["artifact"] = _artifact_identity(artifact_path)
+    meta_path.write_text(
+        json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8"
+    )
+
+
+def _remove_stage_meta(artifact_path):
+    _artifact_meta_path(artifact_path).unlink(missing_ok=True)
+
+
+def _short_status_message(message, limit=240):
+    """Compact optional-stage messages for sidecars; no tracebacks or bulky payloads."""
+    text = " ".join(str(message or "").split())
+    return text[:limit]
+
+
+def _write_optional_stage_status(work_dir, filename, payload):
+    path = Path(work_dir) / filename
+    safe = dict(payload)
+    safe["message"] = _short_status_message(safe.get("message", ""))
+    path.write_text(json.dumps(safe, ensure_ascii=False, indent=2), encoding="utf-8")
+    return path
+
+
+def _write_mimo_overview_status(
+    work_dir, status, message="", artifact=None, *, enabled=None
+):
+    return _write_optional_stage_status(
+        work_dir,
+        "mimo_video_overview.status.json",
+        {
+            "stage": "mimo_video_overview",
+            "enabled": bool(CONFIG["mimo_video_overview"])
+            if enabled is None
+            else bool(enabled),
+            "status": status,
+            "message": message,
+            "artifact": artifact,
+        },
+    )
+
+
+def _merge_overview_into_scenes(scenes, overview_path):
+    """Make the MiMo video-overview the PRIMARY per-scene description when present.
+
+    The frame VLM still provides `frame_facts` (timestamped grounding) and `depth_analysis`;
+    this only replaces the per-scene `description` with the motion-aware video-overview analysis,
+    keeping the original frame description under `frame_description` for provenance/fallback.
+    Scenes whose overview chunk was missing or moderation-rejected keep the frame description.
+
+    In-memory only — `vlm_analysis.json` on disk stays the pure frame-VLM product, so the VLM
+    cache stays coherent and the merge is re-derived (frames + overview) every run. Because
+    `frame_facts` is untouched, `assess_understanding_substrate` (which grades on frame_facts +
+    ASR) cannot regress; richer descriptions can only help.
+    """
+    if not Path(overview_path).exists():
+        return scenes
+    overview = _load_json(overview_path)
+    by_scene = {}
+    for chunk in overview["chunks"]:
+        content = chunk["content"].strip()
+        if _is_mimo_chunk_usable(content):
+            by_scene.setdefault(chunk["scene_id"], []).append(content)
+    if not by_scene:
+        return scenes
+    enriched = 0
+    for scene in scenes:
+        contents = by_scene.get(scene["scene_id"])
+        if not contents:
+            continue
+        scene.setdefault("frame_description", scene.get("description", ""))
+        scene["description"] = "\n".join(contents)
+        scene["description_source"] = "mimo_video_overview"
+        enriched += 1
+    if enriched:
+        log(
+            f"已用 MiMo 视频概览增强 {enriched} 个场景的描述（逐帧 frame_facts 保留作锚点）"
+        )
+    return scenes
+
+
+def _write_consolidation_status(
+    work_dir,
+    status,
+    message="",
+    artifacts=None,
+    *,
+    enabled=True,
+    do_asr=False,
+    do_index=True,
+):
+    return _write_optional_stage_status(
+        work_dir,
+        "consolidation.status.json",
+        {
+            "stage": "consolidation",
+            "enabled": bool(enabled),
+            "do_asr": bool(do_asr),
+            "do_index": bool(do_index),
+            "status": status,
+            "message": message,
+            "artifacts": list(artifacts or []),
+        },
+    )
+
+
+def _present_consolidation_artifacts(work_dir):
+    work_dir = Path(work_dir)
+    return [
+        name
+        for name in ("understanding_index.json", "asr_clean.json")
+        if (work_dir / name).exists()
+    ]
+
+
+def _scene_cache_payload(video_path):
+    return {
+        "schema_version": 1,
+        "stage": "scenes",
+        "inputs": {"video": _video_input(video_path)},
+        "settings": {
+            "scene_threshold": CONFIG.get("scene_threshold"),
+            "scene_junk_filter": CONFIG.get("scene_junk_filter"),
+            "scene_merge_min": CONFIG.get("scene_merge_min"),
+            "scene_junk_dark_luma": CONFIG.get("scene_junk_dark_luma"),
+            "scene_junk_bright_luma": CONFIG.get("scene_junk_bright_luma"),
+            "scene_junk_pixel_ratio": CONFIG.get("scene_junk_pixel_ratio"),
+        },
+    }
+
+
+def _asr_cache_payload(video_path, *, skip_asr=False):
+    return {
+        "schema_version": 1,
+        "stage": "asr",
+        "inputs": {"video": _video_input(video_path)},
+        "settings": {
+            "skip_asr": bool(skip_asr),
+            "mimo_asr_api_key_present": bool(CONFIG.get("mimo_asr_api_key")),
+            "mimo_asr_api_url": CONFIG.get("mimo_asr_api_url"),
+            "mimo_asr_model": CONFIG.get("mimo_asr_model"),
+            "mimo_asr_language": CONFIG.get("mimo_asr_language"),
+            "mimo_asr_base64_max_mb": CONFIG.get("mimo_asr_base64_max_mb"),
+            "asr_segment_seconds": CONFIG.get("asr_segment_seconds"),
+        },
+    }
+
+
+def _asr_cache_state(artifact_path, expected_meta, video_path):
+    """Classify an ASR cache without upgrading stale evidence into new authority."""
+    artifact_path = Path(artifact_path)
+    if not _stage_cache_valid(artifact_path, expected_meta):
+        return "MISS"
+    evidence_path = artifact_path.parent / EVIDENCE_FILENAME
+    if not evidence_path.exists():
+        return "LEGACY_UNVERIFIED"
+    if validate_asr_timing_evidence(evidence_path, video_path, artifact_path):
+        evidence = _load_json(evidence_path)
+        if evidence.get("status") == "LEGACY_UNVERIFIED":
+            return "LEGACY_UNVERIFIED"
+        # An all-empty transcription is an unexplained outcome, not proven silence; treating it
+        # as fresh would make one bad run a permanent cache hit.
+        if evidence.get("status") in {"UNAVAILABLE_NO_DURATION", "EMPTY_UNKNOWN"}:
+            return "MISS"
+        return "FRESH"
+    return "MISS"
+
+
+def _silence_cache_payload(video_path, asr_json):
+    return {
+        "schema_version": 1,
+        "stage": "silence",
+        "inputs": {
+            "video": _video_input(video_path),
+            "asr_result": _artifact_identity(asr_json),
+        },
+        "asr_meta": _load_json(_artifact_meta_path(asr_json))
+        if _artifact_meta_path(asr_json).exists()
+        else None,
+        "settings": {
+            "silence_noise_threshold": CONFIG.get("silence_noise_threshold"),
+            "silence_min_duration": CONFIG.get("silence_min_duration"),
+            "quiet_window_min": CONFIG.get("quiet_window_min"),
+            "silence_merge_gap": CONFIG.get("silence_merge_gap"),
+            "source_boundary_noise_threshold": CONFIG.get(
+                "source_boundary_noise_threshold"
+            ),
+            "source_boundary_min_pause": CONFIG.get("source_boundary_min_pause"),
+            "source_boundary_max_alignment_error": CONFIG.get(
+                "source_boundary_max_alignment_error"
+            ),
+        },
+    }
+
+
+def _vlm_prompt_payload():
+    """The exact prompt/context text the VLM stage sends; compared by equality."""
+    prompt = load_prompt("VLM_DEPTH_PROMPT")
+    if not prompt:
+        prompt = (
+            "仔细观察这些视频帧。分两部分输出：\n"
+            "【描述】不超过80字，描述画面中正在发生什么。\n"
+            "【深层分析】不超过120字，分析角色情绪、关系动态、潜台词。"
+        )
+    context = CONFIG.get("context_info", "")
+    if context:
+        prompt = f"已知信息：{context}\n\n{prompt}"
+    return {"prompt_text": prompt, "context_info": context}
+
+
+def _vlm_cache_payload(video_path, work_dir, scenes_json, frames):
+    return {
+        "schema_version": 1,
+        "stage": "vlm",
+        "inputs": {
+            "video": _video_input(video_path),
+            "scenes": _artifact_identity(scenes_json),
+            "background_research": _artifact_identity(
+                Path(work_dir) / "background_research.json"
+            ),
+        },
+        "frames": _frame_cache_payload(video_path, CONFIG.get("fps"), frames),
+        "prompt": _vlm_prompt_payload(),
+        "settings": {
+            "fps": CONFIG.get("fps"),
+            "vlm_model": CONFIG.get("vlm_model"),
+            "api_url": CONFIG.get("api_url"),
+            "mimo_disable_thinking": CONFIG.get("mimo_disable_thinking", True),
+            "mimo_media_resolution": CONFIG.get("mimo_media_resolution"),
+        },
+    }
+
+
+def _frames_manifest_path(work_dir):
+    return Path(work_dir) / "frames" / "frames_manifest.json"
+
+
+def _frame_cache_payload(video_path, fps, frames):
+    frame_names = [Path(frame).name for frame in frames]
+    return {
+        # v2: frame number→time is (n-1)/fps, not n/fps. Bumping invalidates frames/VLM
+        # artifacts produced under the old off-by-one so they are recomputed, not reused.
+        "schema_version": FRAME_TIME_CONVENTION_VERSION,
+        "inputs": {"video": _video_input(video_path)},
+        "fps": float(fps),
+        "frame_count": len(frames),
+        "frames": frame_names,
+    }
+
+
+def _write_frames_manifest(work_dir, video_path, fps, frames):
+    manifest_path = _frames_manifest_path(work_dir)
+    manifest_path.parent.mkdir(parents=True, exist_ok=True)
+    manifest_path.write_text(
+        json.dumps(
+            _frame_cache_payload(video_path, fps, frames), ensure_ascii=False, indent=2
+        ),
+        encoding="utf-8",
+    )
+
+
+def _frames_cache_valid(video_path, work_dir, fps):
+    frames_dir = Path(work_dir) / "frames"
+    frames = sorted(frames_dir.glob("frame_*.jpg"))
+    if not frames:
+        return False
+    manifest_path = _frames_manifest_path(work_dir)
+    if not manifest_path.exists():
+        return False
+    try:
+        manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+        expected = _frame_cache_payload(video_path, fps, frames)
+    except (OSError, ValueError, TypeError):
+        return False
+    return manifest == expected