@oh-story/dsh 0.1.10 → 0.1.12

package/lib/video-recap/skills/video-script/scripts/evidence_bundle.py

@@ -88,7 +88,9 @@ def coverage_policy_v1(
             "coverage_policy_version": COVERAGE_POLICY_VERSION,
             "selected_ranges": [],
             "dropped_ranges": [],
+            "dropped_range_count": 0,
             "duration": 0.0,
+            "baseline_range_count_before_narration": 0,
         }
     width = min(float(window_seconds), max(5.0, duration / 8.0))
     ranges = [
@@ -345,72 +347,21 @@ def filter_evidence_by_ranges(vlm_analysis, asr_result, ranges, *, timeline="sou
 
 
 def build_review_coverage_metadata(bundle):
-    """Pure compatibility seam: summarize the evidence coverage contract."""
-    items = bundle.get("items") or [] if isinstance(bundle, dict) else []
-    coverage = bundle.get("coverage", {}) if isinstance(bundle, dict) else {}
-    metadata = bundle.get("metadata", {}) if isinstance(bundle, dict) else {}
+    """Summarize a build_evidence_bundle() bundle's coverage contract."""
+    coverage = bundle["coverage"]
+    metadata = bundle["metadata"]
     return {
-        "coverage_policy_version": coverage.get(
-            "coverage_policy_version", COVERAGE_POLICY_VERSION
-        ),
-        "time_ranges": coverage.get("selected_ranges", []),
-        "dropped_ranges": coverage.get("dropped_ranges", []),
-        "dropped_range_count": coverage.get(
-            "dropped_range_count", len(coverage.get("dropped_ranges", []))
-        ),
-        "scene_count": metadata.get(
-            "reviewed_scene_count",
-            sum(1 for item in items if item.get("source") == "visual"),
-        ),
-        "asr_count": metadata.get(
-            "reviewed_asr_count",
-            sum(1 for item in items if item.get("source") == "asr"),
-        ),
-        "dropped_scene_count": metadata.get("dropped_scene_count", 0),
-        "dropped_asr_count": metadata.get("dropped_asr_count", 0),
+        "coverage_policy_version": coverage["coverage_policy_version"],
+        "time_ranges": coverage["selected_ranges"],
+        "dropped_ranges": coverage["dropped_ranges"],
+        "dropped_range_count": coverage["dropped_range_count"],
+        "scene_count": metadata["reviewed_scene_count"],
+        "asr_count": metadata["reviewed_asr_count"],
+        "dropped_scene_count": metadata["dropped_scene_count"],
+        "dropped_asr_count": metadata["dropped_asr_count"],
     }
 
 
-def validate_public_evidence_contract(bundle):
-    """Pure compatibility seam: validate the public evidence bundle shape.
-
-    Returns a non-throwing report so callers can use it in tests or advisory QC paths.
-    """
-    errors = []
-    warnings = []
-    if not isinstance(bundle, dict):
-        return {"valid": False, "errors": ["bundle must be a dict"], "warnings": []}
-    if bundle.get("schema_version") != EVIDENCE_CONTRACT_VERSION:
-        errors.append("unsupported schema_version")
-    if bundle.get("clock") not in ("source", "output"):
-        errors.append("clock must be source or output")
-    for idx, item in enumerate(bundle.get("items") or []):
-        if not isinstance(item, dict):
-            errors.append(f"items[{idx}] must be a dict")
-            continue
-        if item.get("source") not in ("visual", "asr"):
-            errors.append(f"items[{idx}].source must be visual or asr")
-        if item.get("clock") not in ("source", "output"):
-            errors.append(f"items[{idx}].clock must be source or output")
-        if item.get("support") != "direct":
-            warnings.append(f"items[{idx}].support is not direct")
-        start, end = item.get("start"), item.get("end")
-        try:
-            if float(end) <= float(start):
-                errors.append(f"items[{idx}] has non-positive time range")
-        except (TypeError, ValueError):
-            errors.append(f"items[{idx}] has invalid time range")
-    for idx, item in enumerate(bundle.get("context_items") or []):
-        if not isinstance(item, dict):
-            errors.append(f"context_items[{idx}] must be a dict")
-            continue
-        if item.get("clock") is not None:
-            errors.append(f"context_items[{idx}].clock must be null")
-        if item.get("support") != "context_only":
-            errors.append(f"context_items[{idx}].support must be context_only")
-    return {"valid": not errors, "errors": errors, "warnings": warnings}
-
-
 def build_evidence_bundle(
     vlm_analysis,
     asr_result,
@@ -448,30 +399,27 @@ def build_evidence_bundle(
 
 
 def render_evidence_bundle(bundle, *, limit_items=220):
-    clock = str(bundle.get("clock") or "source").upper()
+    clock = bundle["clock"].upper()
     lines = [f"## Timeline evidence (clock={clock}; source=visual/asr)"]
-    items = bundle.get("items") or []
+    items = bundle["items"]
     if not items:
         lines.append("(无 timeline evidence)")
     for item in items[:limit_items]:
-        label = "画面" if item.get("source") == "visual" else "对白"
+        label = "画面" if item["source"] == "visual" else "对白"
         backref = ""
-        if (
-            item.get("clock") == "output"
-            and "source_start" in item
-            and "source_end" in item
-        ):
-            backref = f" ← SOURCE {float(item['source_start']):.1f}-{float(item['source_end']):.1f}s"
-            if item.get("output_segment_index") is not None:
-                backref += f" clip#{item.get('output_segment_index')}"
+        # Remapped cut_output evidence carries its source-time provenance.
+        if "source_start" in item:
+            backref = f" ← SOURCE {item['source_start']:.1f}-{item['source_end']:.1f}s"
+            if "output_segment_index" in item:
+                backref += f" clip#{item['output_segment_index']}"
         lines.append(
-            f"[{clock} {float(item.get('start', 0)):.1f}-{float(item.get('end', 0)):.1f}s {label} id={item.get('id')}{backref}] {item.get('text', '')}"
+            f"[{clock} {item['start']:.1f}-{item['end']:.1f}s {label} id={item['id']}{backref}] {item['text']}"
         )
     if len(items) > limit_items:
         lines.append(
             f"... dropped from prompt: {len(items) - limit_items} items (artifact metadata keeps counts)"
         )
-    context = bundle.get("context_items") or []
+    context = bundle["context_items"]
     lines.extend(
         [
             "",
@@ -482,7 +430,7 @@ def render_evidence_bundle(bundle, *, limit_items=220):
         lines.append("(无 context-only evidence)")
     for item in context[:40]:
         lines.append(
-            f"[clock=null {item.get('source')} support=context_only id={item.get('id')}] {item.get('text', '')}"
+            f"[clock=null {item['source']} support=context_only id={item['id']}] {item['text']}"
         )
     return "\n".join(lines)
 

package/lib/video-recap/skills/video-script/scripts/lib.py

@@ -1,7 +1,6 @@
 """Self-contained config + utilities for this skill (no cross-skill imports).
 Merged from the shared core; reads the same env vars as the rest of the bundle."""
 import json
-import hashlib
 import math
 import os
 import re
@@ -22,8 +21,6 @@ MIMO_TOKEN_PLAN_API_URLS = {
     "ams": "https://token-plan-ams.xiaomimimo.com/v1",
 }
 DEFAULT_MIMO_MODEL = "mimo-v2.5"          # VLM / chat (vision understanding)
-DEFAULT_MIMO_ASR_MODEL = "mimo-v2.5-asr"  # speech-to-text
-DEFAULT_MIMO_TTS_MODEL = "mimo-v2.5-tts"  # text-to-speech
 
 
 def normalize_api_url(raw_url):
@@ -99,32 +96,13 @@ def env_float(name, default, *, minimum=None):
 # are optional and fall back to MIMO_API_KEY / MIMO_API_URL. Token-Plan keys (tp-*) auto-
 # route to the Token-Plan cluster base URL; pay-as-you-go keys use api.xiaomimimo.com.
 _mimo_api_key = os.environ.get("MIMO_API_KEY", "")
-_mimo_video_api_key = os.environ.get("MIMO_VIDEO_API_KEY", "") or _mimo_api_key
 _raw_api_url = os.environ.get("MIMO_API_URL") or default_mimo_api_url(is_mimo_token_plan_key(_mimo_api_key))
-_raw_mimo_video_api_url = (
-    os.environ.get("MIMO_VIDEO_API_URL")
-    or os.environ.get("MIMO_API_URL")
-    or default_mimo_api_url(is_mimo_token_plan_key(_mimo_video_api_key))
-)
 
 CONFIG = {
     "api_url": normalize_api_url(_raw_api_url),
     "api_key": _mimo_api_key,
-    "api_key_source": "MIMO_API_KEY",
-    "mimo_video_api_url": normalize_api_url(_raw_mimo_video_api_url),
-    "mimo_video_model": os.environ.get("MIMO_VIDEO_MODEL") or os.environ.get("MIMO_MODEL", DEFAULT_MIMO_MODEL),
+    "api_env_var": "MIMO_API_KEY",
     "vlm_model": os.environ.get("MIMO_MODEL", DEFAULT_MIMO_MODEL),
-    "mimo_media_resolution": os.environ.get("MIMO_MEDIA_RESOLUTION", "default"),
-    "mimo_video_overview": env_bool("MIMO_VIDEO_OVERVIEW", False),  # opt-in (--mimo-video-overview / =1); when on it becomes the PRIMARY per-scene description, frames stay the anchor/fallback
-    "mimo_video_fps": env_float("MIMO_VIDEO_FPS", 3.0, minimum=0.1),
-    "mimo_video_chunk_max_seconds": env_float("MIMO_VIDEO_CHUNK_MAX_SECONDS", 20.0, minimum=1.0),
-    "mimo_video_chunk_min_seconds": env_float("MIMO_VIDEO_CHUNK_MIN_SECONDS", 1.0, minimum=0.2),
-    "mimo_video_base64_max_mb": env_float("MIMO_VIDEO_BASE64_MAX_MB", 45.0, minimum=1.0),
-    "mimo_video_prompt": os.environ.get(
-        "MIMO_VIDEO_PROMPT",
-        "请用中文分析这个视频分片的主要人物、场景变化、关键动作、情绪走向和剧情冲突，"
-        "重点提取适合写短视频解说的故事线索。不要泛泛复述画面，要标出对后续写稿有用的信息。",
-    ),
     "mimo_disable_thinking": env_bool("MIMO_DISABLE_THINKING", True),
     # TTS 语速（字符/秒）。实测 mimo-tts 冰糖音色中位 ~3.9 字/秒，可用 SPEECH_RATE 覆盖
     # 生成解说时使用 speech_rate * safety_margin 作为约束
@@ -134,7 +112,6 @@ CONFIG = {
     "narration_coverage_target": 0.7,   # rough first-draft/diagnostic fallback; content-led audio decisions may differ (not a quota)
     "narration_coverage_max": 0.85,     # above this coverage → no_original_blocks (narration is wall-to-wall)
     "narration_coverage_min": 0.5,      # below this coverage → under_narrated
-    "narration_block_seconds": 9.0,     # block cadence used to derive target block count
     "original_block_min_seconds": 2.5,  # a deliberate original-audio gap must be at least this long
     "narration_block_min_chars": 16,    # below this avg block size → fragmented_beats
     "breath_ms": 250,  # 段间呼吸空间(ms)；block recap 块内连贯、块间留原声呼吸
@@ -145,73 +122,19 @@ CONFIG = {
     "visual_beat_max_facts": 3,  # 单段解说最多建议覆盖的 frame_facts 锚点数量
     "asr_chunk_min_chars": env_int("ASR_CHUNK_MIN_CHARS", 500, minimum=1),  # brief 中 ASR 写作分块最小字数/词数
     "asr_chunk_max_chars": env_int("ASR_CHUNK_MAX_CHARS", 800, minimum=1),  # brief 中 ASR 写作分块最大字数/词数
-    "context_info": "",              # 额外上下文（节目名、角色名等）
     "edit_mode": os.environ.get("EDIT_MODE", "full"),  # full | cut
-    "target_duration": os.environ.get("TARGET_DURATION", ""),  # cut 模式目标成片时长，如 10m
 }
 
-def narration_tempo_budget(tts_rate_offset=0.0, *, config=None):
-    """Return the canonical tempo budget shared by voiceover and assemble."""
-    cfg = config or CONFIG
-    global_speed = max(0.01, float(cfg.get("narration_speed", 1.0) or 1.0))
-    rate_factor = max(0.01, 1.0 + float(tts_rate_offset or 0.0))
-    cumulative_max = max(1.0, float(cfg.get("narration_cumulative_tempo_max", 1.35) or 1.35))
-    hard_max = max(cumulative_max, float(cfg.get("narration_cumulative_tempo_hard_max", 1.40) or 1.40))
-    legacy_segment_cap = max(1.0, float(cfg.get("tts_segment_tempo_max", 1.20) or 1.20))
-    segment_tempo_max = max(1.0, min(legacy_segment_cap, cumulative_max / (global_speed * rate_factor)))
-    return {
-        "global_narration_speed": global_speed,
-        "tts_rate_factor": rate_factor,
-        "cumulative_tempo_max": cumulative_max,
-        "cumulative_tempo_hard_max": hard_max,
-        "segment_tempo_max": segment_tempo_max,
-        "max_raw_duration_factor": global_speed * segment_tempo_max,
-    }
-
 def log(msg):
     print(f"[video-recap] {msg}", flush=True)
 
-def stable_json_dumps(value):
-    """Serialize values deterministically for non-secret cache fingerprints."""
-    return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"), default=str)
-
-def stable_hash(value):
-    """Return an md5 digest for deterministic JSON-serializable values."""
-    return hashlib.md5(stable_json_dumps(value).encode("utf-8")).hexdigest()
-
-_FILE_FINGERPRINT_MEMO = {}
-
-
-def _file_identity(path):
-    """(device, inode, size, mtime_ns) — changes whenever the bytes could have changed."""
+def file_identity(path):
+    """{size, mtime_ns} of an input file: the identity brief consumers compare against
+    the provenance a producer stored, instead of re-hashing bytes."""
     st = os.stat(os.fspath(path))
-    return (st.st_dev, st.st_ino, st.st_size, st.st_mtime_ns)
-
+    return {"size": st.st_size, "mtime_ns": st.st_mtime_ns}
 
-def file_fingerprint(path, chunk_size=1024 * 1024):
-    """Return a full-content fingerprint for cache-correct identity checks.
 
-    The digest covers CONTENT only — never the path or mtime — so a copied video or
-    artifact is still recognised as the same asset, while any byte change invalidates
-    the cache even if timestamps, size, head, or tail bytes are misleading.
-
-    Identity metadata is used ONLY to memoize within a single process. One understanding
-    run fingerprints the same source video 8-10 times and the whole extracted frame set
-    2-3 times; on a 40-minute video at fps=1 that is gigabytes of redundant reads before
-    any real work starts. A file rewritten in place gets a new (size, mtime_ns) and is
-    re-hashed, so the memo can never serve a stale digest.
-    """
-    key = _file_identity(path)
-    memoized = _FILE_FINGERPRINT_MEMO.get(key)
-    if memoized is not None:
-        return memoized
-    h = hashlib.sha256()
-    with open(os.fspath(path), "rb") as f:
-        for chunk in iter(lambda: f.read(chunk_size), b""):
-            h.update(chunk)
-    digest = h.hexdigest()
-    _FILE_FINGERPRINT_MEMO[key] = digest
-    return digest
 def _retry_after_seconds(value, fallback):
     """Parse Retry-After seconds or HTTP-date; return fallback on malformed input."""
     if not value:
@@ -245,7 +168,7 @@ def _sanitize_api_error(value, limit=500):
 def _api_headers(api_provider=None, api_url=None, api_key=None):
     """Build MiMo auth headers (OpenAI-compatible chat/completions with an api-key header)."""
     del api_provider, api_url  # MiMo is the only provider; signature kept for call sites
-    key = CONFIG.get("api_key", "") if api_key is None else api_key
+    key = CONFIG["api_key"] if api_key is None else api_key
     return {
         "Content-Type": "application/json",
         "User-Agent": "video-recap/1.0",
@@ -258,9 +181,9 @@ def _prepare_api_payload(payload, api_provider=None, api_url=None):
     normalized = dict(payload)
     if "max_tokens" in normalized and "max_completion_tokens" not in normalized:
         normalized["max_completion_tokens"] = normalized.pop("max_tokens")
-    model = str(normalized.get("model") or "")
+    model = normalized["model"]
     if (
-        CONFIG.get("mimo_disable_thinking", True)
+        CONFIG["mimo_disable_thinking"]
         and not model.endswith(("-tts", "-asr"))
         and "thinking" not in normalized
     ):
@@ -269,7 +192,7 @@ def _prepare_api_payload(payload, api_provider=None, api_url=None):
         normalized["thinking"] = {"type": "disabled"}
     return normalized
 
-def api_call(payload, max_retries=8, *, api_provider=None, api_url=None, api_key=None, api_key_source=None):
+def api_call(payload, max_retries=8, *, api_provider=None, api_url=None, api_key=None, api_env_var=None):
     """调用 OpenAI-compatible API，带重试。
 
     集群的 429 限流是常态而非错误，所以重试更耐心（更多次数 + 退避封顶 60s + 遵从 Retry-After），
@@ -292,7 +215,7 @@ def api_call(payload, max_retries=8, *, api_provider=None, api_url=None, api_key
                 wait = _retry_after_seconds(retry_after, max(wait, 10))
                 log(f"API 速率限制 (尝试 {attempt+1}/{max_retries}), 等待 {wait}s")
             elif e.code == 401:
-                key_name = api_key_source or CONFIG.get("api_key_source", "MIMO_API_KEY")
+                key_name = api_env_var or CONFIG["api_env_var"]
                 raise RuntimeError(f"API 认证失败 (401)。请检查 {key_name} 和 API URL 是否匹配。")
             elif e.code == 403:
                 hint = "API 访问被拒绝 (403)。"

package/lib/video-recap/skills/video-script/scripts/narration_lint.py

@@ -5,6 +5,7 @@ timing and text checks live here, and every later consumer trusts its result.
 """
 
 import json
+import math
 from pathlib import Path
 
 from lib import CONFIG, log
@@ -32,7 +33,11 @@ def _lint_issue(level, index, code, message, **extra):
 
 
 def _is_number(value):
-    return isinstance(value, (int, float)) and not isinstance(value, bool)
+    return (
+        isinstance(value, (int, float))
+        and not isinstance(value, bool)
+        and math.isfinite(value)
+    )
 
 
 def _visual_overlay_issues(index, seg):
@@ -115,17 +120,13 @@ def _clip_span(clip):
     return clip["start"], clip["end"]
 
 
-def _clip_matches_for_segment(seg, clip_plan):
+def _clip_matches_for_segment(seg, clip_plan, requested_clip_id):
     if not clip_plan:
         return []
     clips = clip_plan["clips"]
     midpoint = (seg["start"] + seg["end"]) / 2
-    if seg.get("source_clip_id") is not None:
-        try:
-            requested = int(seg["source_clip_id"])
-        except (TypeError, ValueError):
-            return []
-        clips = [clip for clip in clips if clip.get("clip_id") == requested]
+    if requested_clip_id is not None:
+        clips = [clip for clip in clips if clip.get("clip_id") == requested_clip_id]
     return [
         clip
         for clip in clips
@@ -196,9 +197,13 @@ def _has_connected_predecessor(narration, idx, start):
 
 
 def lint_narration(
-    narration, scenes_analysis=None, *, clip_plan=None, mode="full", work_dir=None
+    narration, scenes_analysis=None, *, clip_plan=None, mode="full", work_dir=None,
+    require_chronological=False,
 ):
-    """Preflight-check agent narration before TTS; write narration_lint.json when work_dir is set."""
+    """Preflight-check agent narration before TTS; write narration_lint.json when work_dir is set.
+
+    Segments are sorted by start for the timing checks; ``require_chronological`` (the
+    --preserve-approved-text contract) additionally rejects input that is not already in order."""
     scenes_analysis = scenes_analysis or []
     errors = []
     warnings = []
@@ -215,6 +220,7 @@ def lint_narration(
             )
         )
     else:
+        previous_start = None
         for idx, seg in enumerate(narration):
             if not isinstance(seg, dict):
                 errors.append(
@@ -230,33 +236,47 @@ def lint_narration(
             if not _is_number(start) or not _is_number(end):
                 errors.append(
                     _lint_issue(
-                        "error", idx, "invalid_time", "start/end must be numeric"
+                        "error", idx, "invalid_time", "start/end must be finite numbers"
                     )
                 )
                 continue
-            text = str(seg.get("narration", "")).strip()
-            try:
-                pause = int(seg.get("pause_after_ms", CONFIG["breath_ms"]))
-            except (TypeError, ValueError):
+            if require_chronological and previous_start is not None and start < previous_start:
                 errors.append(
                     _lint_issue(
                         "error",
                         idx,
-                        "invalid_pause",
-                        "pause_after_ms must be an integer number of milliseconds",
+                        "out_of_order",
+                        "Segments must be listed in chronological order",
+                        start=start,
+                        previous_start=previous_start,
+                    )
+                )
+            previous_start = start
+            text = seg.get("narration")
+            if not isinstance(text, str):
+                errors.append(
+                    _lint_issue(
+                        "error",
+                        idx,
+                        "invalid_narration",
+                        "narration must be a string",
+                        start=start,
+                        end=end,
                     )
                 )
                 continue
-            if pause < 0:
-                warnings.append(
+            text = text.strip()
+            pause = seg.get("pause_after_ms", CONFIG["breath_ms"])
+            if not isinstance(pause, int) or isinstance(pause, bool) or pause < 0:
+                errors.append(
                     _lint_issue(
-                        "warning",
+                        "error",
                         idx,
-                        "negative_pause",
-                        "pause_after_ms is negative; default should be used",
-                        pause_after_ms=pause,
+                        "invalid_pause",
+                        "pause_after_ms must be a non-negative integer number of milliseconds",
                     )
                 )
+                continue
             errors.extend(_visual_overlay_issues(idx, seg))
             if end <= start:
                 errors.append(
@@ -388,7 +408,21 @@ def lint_narration(
                 )
 
             if mode == "cut":
-                matches = _clip_matches_for_segment(seg, clip_plan)
+                requested_clip_id = seg.get("source_clip_id")
+                if requested_clip_id is not None:
+                    try:
+                        requested_clip_id = int(requested_clip_id)
+                    except (TypeError, ValueError):
+                        errors.append(
+                            _lint_issue(
+                                "error",
+                                idx,
+                                "invalid_source_clip_id",
+                                "source_clip_id must be an integer",
+                            )
+                        )
+                        continue
+                matches = _clip_matches_for_segment(seg, clip_plan, requested_clip_id)
                 if not matches:
                     errors.append(
                         _lint_issue(
@@ -400,7 +434,7 @@ def lint_narration(
                             end=end,
                         )
                     )
-                elif len(matches) > 1 and seg.get("source_clip_id") is None:
+                elif len(matches) > 1 and requested_clip_id is None:
                     errors.append(
                         _lint_issue(
                             "error",
@@ -426,18 +460,6 @@ def lint_narration(
                                 clip_end=round(clip_end, 3),
                             )
                         )
-                if seg.get("source_clip_id") is not None:
-                    try:
-                        int(seg["source_clip_id"])
-                    except (TypeError, ValueError):
-                        errors.append(
-                            _lint_issue(
-                                "error",
-                                idx,
-                                "invalid_source_clip_id",
-                                "source_clip_id must be an integer",
-                            )
-                        )
 
             normalized.append(
                 {"index": idx, "start": start, "end": end, "char_count": char_count}
@@ -620,10 +642,12 @@ def lint_narration(
 
 
 def validate_narration_or_raise(
-    narration, scenes_analysis=None, *, clip_plan=None, mode="full", work_dir=None
+    narration, scenes_analysis=None, *, clip_plan=None, mode="full", work_dir=None,
+    require_chronological=False,
 ):
     report = lint_narration(
-        narration, scenes_analysis, clip_plan=clip_plan, mode=mode, work_dir=work_dir
+        narration, scenes_analysis, clip_plan=clip_plan, mode=mode, work_dir=work_dir,
+        require_chronological=require_chronological,
     )
     if report["errors"]:
         sample = "; ".join(

package/lib/video-recap/skills/video-script/scripts/review.py

@@ -7,7 +7,6 @@ from evidence_bundle import (
     coverage_policy_v1,
     filter_evidence_by_ranges,
     render_evidence_bundle,
-    validate_public_evidence_contract,
 )
 from review_grounding import remap_grounding_to_output_timeline
 from review_response import (
@@ -34,7 +33,6 @@ __all__ = [
     "remap_grounding_to_output_timeline",
     "render_evidence_bundle",
     "review_narration",
-    "validate_public_evidence_contract",
     "write_grounding_qc",
 ]
 

package/lib/video-recap/skills/video-script/scripts/review_grounding.py

@@ -1,22 +1,33 @@
 """Load and remap source evidence for narration review."""
 
 import json
+from pathlib import Path
 
-import math
 
+def _load(work_dir, name):
+    """Pipeline-written artifact: None when never written; corrupt JSON raises."""
+    path = Path(work_dir) / name
+    if not path.exists():
+        return None
+    return json.loads(path.read_text(encoding="utf-8"))
 
-from pathlib import Path
 
-from lib import stable_hash
+def _load_required(work_dir, name, hint):
+    """Pipeline-written artifact the stage cannot run without; corrupt JSON raises."""
+    path = Path(work_dir) / name
+    if not path.exists():
+        raise SystemExit(f"缺少 {path}；{hint}")
+    return json.loads(path.read_text(encoding="utf-8"))
 
 
-def _load(work_dir, name):
+def _load_agent_optional(work_dir, name):
+    """Optional agent-authored artifact: missing or unparseable both fail open to None."""
     path = Path(work_dir) / name
     if not path.exists():
         return None
     try:
         return json.loads(path.read_text(encoding="utf-8"))
-    except (ValueError, OSError):
+    except ValueError:
         return None
 
 
@@ -79,19 +90,6 @@ def _load_review_grounding(work_dir):
     )
 
 
-def _source_fingerprint(work_dir, name):
-    path = Path(work_dir) / name
-    if not path.exists():
-        return ""
-    try:
-        return stable_hash(json.loads(path.read_text(encoding="utf-8")))
-    except (ValueError, OSError):
-        try:
-            return stable_hash(path.read_text(encoding="utf-8"))
-        except OSError:
-            return ""
-
-
 def _load_cut_clip_spans(work_dir):
     """Load explicit source→output spans from the validated cut plan only.
 
@@ -102,50 +100,28 @@ def _load_cut_clip_spans(work_dir):
     """
     work_dir = Path(work_dir)
     plan = _load(work_dir, "clip_plan_validated.json")
-    if not isinstance(plan, dict):
+    if plan is None:
         return None
-    raw_plan = _load(work_dir, "clip_plan.json")
-    if raw_plan is not None and plan.get("raw_plan_fingerprint") != stable_hash(
-        raw_plan
+    raw_path = work_dir / "clip_plan.json"
+    if (
+        raw_path.exists()
+        and (work_dir / "clip_plan_validated.json").stat().st_mtime_ns
+        < raw_path.stat().st_mtime_ns
     ):
         return None
-    clips = plan.get("clips")
-    if not isinstance(clips, list):
-        return None
-    spans = []
-    for clip in clips:
-        if not isinstance(clip, dict):
-            continue
-        if not all(
-            key in clip
-            for key in ("source_start", "source_end", "output_start", "output_end")
-        ):
-            return None
-        try:
-            source_start = float(clip["source_start"])
-            source_end = float(clip["source_end"])
-            output_start = float(clip["output_start"])
-            output_end = float(clip["output_end"])
-        except (TypeError, ValueError):
-            return None
-        values = (source_start, source_end, output_start, output_end)
-        if not all(math.isfinite(value) for value in values):
-            return None
-        if source_end <= source_start or output_end <= output_start:
-            return None
-        spans.append(
-            {
-                "source_start": source_start,
-                "source_end": source_end,
-                "output_start": output_start,
-                "output_end": output_end,
-                "source_id": str(clip.get("source_id", clip.get("source", "0"))),
-                "source_clip_id": clip.get(
-                    "source_clip_id", clip.get("id", clip.get("clip_id"))
-                ),
-                "output_segment_index": len(spans),
-            }
-        )
+    spans = [
+        {
+            "source_start": clip["source_start"],
+            "source_end": clip["source_end"],
+            "output_start": clip["output_start"],
+            "output_end": clip["output_end"],
+            # video-cut labels source_id only for multi-source plans.
+            "source_id": str(clip.get("source_id", "0")),
+            "source_clip_id": clip["clip_id"],
+            "output_segment_index": index,
+        }
+        for index, clip in enumerate(plan["clips"])
+    ]
     return spans or None