@oh-story/dsh 0.1.12 → 0.1.13

package/lib/video-recap/skills/video-script/SKILL.md

@@ -23,7 +23,7 @@ description: >
 4. 声音/旁白编辑
 5. 第一次观看的观众
 
-Agent 先记录简洁决定，再写时间线产物。`validate.py` 负责对理解索引做机械校验；full 模式默认还会执行预算整理并计算旁白的原声重叠。已有批准稿应加 `--preserve-approved-text`，保留段落顺序、数量、时间、文本、停顿和扩展元数据，仅允许依据现有声音证据更新 `overlaps_speech`。
+Agent 先记录简洁决定，再写时间线产物。`validate.py` 负责对理解索引做机械校验，从不改写 Agent 的稿子：段落顺序、数量、时间、文本、停顿和扩展元数据原样保留，只依据现有声音证据回写实测的 `overlaps_speech`。文本装不下时间窗、段落未按时间排序等问题以 error 退回给 Agent 修改。
 
 下面的 `scripts/...` 均相对于本技能目录。若执行器从仓库根目录启动，请给脚本路径加上本技能的绝对目录。
 
@@ -44,8 +44,9 @@ REVISION 先明确本轮修改项与冻结项，再编辑对应层：表达、
 - `work_dir/agent_narration_brief.md`：场景、时长、安静窗口与字数预算。
 - `asr_writing_chunks.json`：长对白的写作分块。
 - `timeline_fusion.json`：判断某段是否有对白或静音槽。
-- `vlm_analysis.json` / `asr_result.json`：核对具体画面与原声证据。
+- `vlm_analysis.json` / `asr_result.json`：核对具体画面与原声证据；有 `asr_clean.json` 时以它的文本为准（lint、评审、剪辑和合成都读它）。
 - brief 顶部列出的 contact sheet：不要只依赖场景摘要；反应、走位、静止和台词前后的具体时刻常常更重要。
+- `production_reference.json`（仅当 `work_dir` 里有）：另一部成片拆出的可迁移方法与节奏数值，用法见 §3。
 
 full 模式使用原片时间。cut 模式第一阶段只写 `clip_plan.json`；`edited_source.mp4` 产生后，第二阶段才按输出时间写 `narration.json`。
 
@@ -68,6 +69,8 @@ full 模式使用原片时间。cut 模式第一阶段只写 `clip_plan.json`；
 
 只记录决定、证据锚点、被放弃的备选方案和简短理由，不写冗长思维过程。
 
+若 `work_dir` 有 `production_reference.json`，制定方案前先读它。它来自另一部成片，只含可迁移的方法和测得的节奏，不含本片事实，不能作为本片画面、剧情或台词的证据。优先级：用户指令 > 本片证据 > 参考。CREATE 可把它的 `structure` 当作一个候选假设，与素材自生的假设比较；DIRECTED / REVISION 默认不套用。`targets` 是参考值，不是配额：与本片的 `audio_owner`、完整台词或表演冲突时以素材为准。可在 `recap_story_plan.json` 写可选字段 `reference_methods: [{"id": "m1", "decision": "adopt|adapt|skip", "note": "…"}]`。没有这个文件就跳过本段。
+
 ### 3.1 导演判断
 
 锁定：
@@ -153,7 +156,7 @@ full 模式直接按原片时间写；cut 第二阶段先查看 `edited_source.m
 
 | 字段 | 含义 |
 |------|------|
-| `start` / `end` | full 模式为原片时间；cut 第二阶段为输出时间 |
+| `start` / `end` | full 模式为原片时间；cut 第二阶段为输出时间。与上一块间隔不超过 1.6 秒的块属于同一段落，assemble 会让它紧接上一块的实际结尾（间隔 0.35 秒）播放，最多比 `start` 提前 1.2 秒，且提前的那一段不会进入原声对白；段落首块从 `start` 开始，上一块超时则顺延到上一块结尾加停顿之后 |
 | `narration` | 解说文本 |
 | `pause_after_ms` | 段后停顿，默认 250ms |
 | `overlaps_speech` | 是否与原对白重叠；连续铺底窗口通常为 `true`，真正静音槽才为 `false` |
@@ -165,7 +168,7 @@ full 模式直接按原片时间写；cut 第二阶段先查看 `edited_source.m
 2. **按连续思路写**：旁白拥有一个 beat 时，用一个或少量完整句子完成“前提 → 触发动作 → 变化/意义”，并在一次 TTS 中合成。句号服从口语思路和呼吸，不服从字幕换行；不要固定句数，也不要“一句一停”。
 3. **7:3 不是配额**：只在素材判断不足时作为避免墙到墙旁白的粗略首稿参考。实际比例服从 `audio_owner`；强对白、动作声或沉默可以完整拥有一个 beat。
 4. **视听接力**：旁白若引出原声，块尾要让观众想听；原声结束后的下一块要承接它造成的变化。
-5. **按有效语速控量**：用 `字数 / brief 头部 speech budget` 估算窗口；装不下时删减或拆分叙事任务，不用加速堆字。
+5. **按有效语速控量**：用 `字数 / brief 头部 speech budget` 估算朗读秒数，每块再加约 0.45 秒 TTS 首尾静音。brief 里每个窗口标的字数没扣这段静音，2–3 秒的短窗口要比它少写一两个字；装不下时删减或拆分叙事任务，不用加速堆字。
 6. **不看图说话**：旁白只增加上下文、因果、预期、证据支持的解释或跨越。
 7. **人物与证据优先**：优先使用已知角色名；关系、动机、潜台词和结果必须指向 visual / ASR / research / user context，且不能把背景资料伪装成当前画面事实。
 8. **写给耳朵听**：使用具体名词和动词，句子完整、口语可听；避免字幕腔、半句、空泛拔高和破折号。TTS 文本先保证听感连续，字幕再按阅读宽度拆分，不能反过来把朗读稿切碎。
@@ -218,7 +221,7 @@ python3 scripts/review.py --work-dir <work_dir>
 
 重复修改并评审，直到：
 
-- `verdict` 为 `PASS` / `OK` 且没有 `error`；或
+- `verdict` 为 `PASS` 且没有 `error`；或
 - 对仍保留的问题做明确 override。
 
 覆盖决定追加到 `work_dir/narration_review_override.md`：
@@ -237,11 +240,10 @@ python3 scripts/review.py --work-dir <work_dir>
 
 ```bash
 python3 scripts/validate.py --work-dir <work_dir> --mode full
-python3 scripts/validate.py --work-dir <work_dir> --mode full --preserve-approved-text
 # cut 输出时间线由编排器使用 --mode cut_output
 ```
 
-命令写出 `narration_lint.json`。full 模式默认执行字符预算整理、去重合并并依据安静窗口计算 `overlaps_speech`，但不会把时间段移动到安静窗口；`--preserve-approved-text` 则保留批准稿的原始时间、文本、停顿、顺序与扩展元数据，只允许更新实测 `overlaps_speech`。修复所有 error 后重复运行，直到校验干净，再继续 TTS 与合成。
+命令写出 `narration_lint.json`。full 与 cut_output 用同一套声音归属算法（原声对白区间减去安静窗口）回写 `overlaps_speech`，其余字段原样保留，不截短、不合并、不补标点、不重排。推荐字数按时间窗先扣 0.45 秒 TTS 首尾静音再计算；full 模式下某段字数超过推荐字数的 1.25 倍即报 `over_budget` error，报告里写明时间窗、`budget_chars`、`limit_chars`、`actual_chars` 和 `over_chars`：缩短文字或放宽/挪动时间窗，不要指望 TTS 替你缩稿。有 error 时命令以非零退出，逐块列出「段 N」（narration.json 里第 N 块，从 1 数；`narration_lint.json` 的 `index` 仍从 0 数）、错误码、关键数字和改法。修复所有 error 后重复运行，直到校验干净，再继续 TTS 与合成。
 
 片名或题材明确但缺少剧情上下文时，先按本技能的 `references/research-guide.md` 写 `background_research.json`。若理解素材偏薄，brief 中的数量只能当上限：宁可少写、写实，也不要为凑数复述画面。
 

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

@@ -1,19 +1,8 @@
-"""Normalize, split, budget, and de-duplicate narration text."""
+"""Count and budget agent-written narration text for lint."""
 
-import copy
 import re
 
-from lib import CONFIG, log
-from deslop_qc import _sentence_pieces, _text_units
-
-
-def _format_frame_facts(scene):
-    """将帧动作描述格式化为可注入 agent brief 的文本。"""
-    facts = scene.get("frame_facts", {})
-    if not facts:
-        return ""
-    lines = [f"    {ts}s: {'; '.join(facts[ts])}" for ts in sorted(facts, key=float)]
-    return "\n  帧动作:\n" + "\n".join(lines)
+from lib import CONFIG
 
 
 def _text_char_count(text):
@@ -27,214 +16,12 @@ def _text_char_count(text):
     )
 
 
-def _split_text_by_sentence_windows(text, min_chars=500, max_chars=800):
-    """Clipto-style three-tier sentence boundary splitting for long ASR text."""
-    text = re.sub(r"\s+", " ", text).strip()
-    if not text:
-        return []
-    if _text_units(text) <= max_chars:
-        return _sentence_pieces(text)
-
-    result = []
-    rest = text
-    sentence_marks = "。！？!?；;."
-    while _text_units(rest) > max_chars:
-        # The min/max thresholds are unit-based but punctuation is char-indexed.
-        # For Chinese (the dominant recap target) these are nearly identical; for
-        # non-CJK this remains a safe sentence-boundary heuristic around words.
-        char_min = min(len(rest), max(1, min_chars))
-        char_max = min(len(rest), max(1, max_chars))
-        window = rest[:char_max]
-        cut = max(window.rfind(mark) for mark in sentence_marks)
-        if cut + 1 < char_min:
-            outside = -1
-            for i, ch in enumerate(rest[char_max:], start=char_max):
-                if ch in sentence_marks:
-                    outside = i
-                    break
-            cut = outside if outside >= 0 and outside + 1 <= len(rest) else char_max - 1
-        piece = rest[: cut + 1].strip()
-        if not piece:
-            piece = rest[:char_max].strip()
-            cut = char_max - 1
-        result.append(piece)
-        rest = rest[cut + 1 :].strip()
-    if rest:
-        result.append(rest)
-    return result
-
-
-def _timed_sentence_pieces(seg, min_chars, max_chars):
-    """Split one ASR segment into timed sentence pieces with approximate spans."""
-    text = seg["text"].strip()
-    if not text:
-        return []
-    start, end = seg["start"], seg["end"]
-    pieces = []
-    for sentence in _sentence_pieces(text):
-        if _text_units(sentence) > max_chars:
-            pieces.extend(
-                _split_text_by_sentence_windows(
-                    sentence, min_chars=min_chars, max_chars=max_chars
-                )
-            )
-        else:
-            pieces.append(sentence)
-    total_units = sum(max(1, _text_units(piece)) for piece in pieces)
-    duration = end - start
-    cursor = start
-    timed = []
-    for idx, piece in enumerate(pieces):
-        units = max(1, _text_units(piece))
-        piece_end = end if idx == len(pieces) - 1 else cursor + duration * units / total_units
-        timed.append(
-            {
-                "start": round(cursor, 2),
-                "end": round(piece_end, 2),
-                "text": piece,
-                "char_count": _text_units(piece),
-            }
-        )
-        cursor = piece_end
-    return timed
-
-
-def _scene_ids_for_range(scenes, start, end):
-    duration = max(0.001, end - start)
-    scene_ids = []
-    for scene in scenes:
-        overlap = _overlap_seconds(start, end, scene["start"], scene["end"])
-        # Ignore tiny boundary tails from approximate ASR sentence timing. A
-        # scene id should mean the chunk materially belongs to that scene.
-        if overlap and (overlap >= duration * 0.2 or overlap >= 3.0):
-            scene_ids.append(scene["scene_id"])
-    return scene_ids
-
-
-def _chunk_asr_for_writing(segments, scenes_analysis, min_chars=None, max_chars=None):
-    """Chunk ASR into semantic windows before an agent writes long-dialogue recaps.
-
-    The strategy mirrors Clipto's segment splitter: accumulate a window, prefer
-    the last sentence boundary inside max length, allow a slightly longer first
-    boundary outside the window, and fall back to the remaining text. CJK text is
-    measured by characters; non-CJK text is measured by words.
-    """
-    min_chars = CONFIG["asr_chunk_min_chars"] if min_chars is None else min_chars
-    max_chars = CONFIG["asr_chunk_max_chars"] if max_chars is None else max_chars
-    pieces = [
-        piece
-        for seg in segments
-        for piece in _timed_sentence_pieces(seg, min_chars, max_chars)
-    ]
-
-    chunks = []
-    current = []
-    current_units = 0
-    current_scene_ids = set()
-
-    def flush():
-        nonlocal current, current_units, current_scene_ids
-        if not current:
-            return
-        chunks.append(
-            {
-                "chunk_id": len(chunks),
-                "start": current[0]["start"],
-                "end": current[-1]["end"],
-                "scene_ids": sorted(
-                    current_scene_ids, key=lambda sid: (isinstance(sid, str), sid)
-                ),
-                "char_count": current_units,
-                "text": " ".join(piece["text"] for piece in current).strip(),
-                "segments": current,
-            }
-        )
-        current = []
-        current_units = 0
-        current_scene_ids = set()
-
-    for piece in pieces:
-        units = max(1, piece["char_count"])
-        piece_scene_ids = set(
-            _scene_ids_for_range(scenes_analysis, piece["start"], piece["end"])
-        )
-        crosses_scene = (
-            current
-            and current_scene_ids
-            and piece_scene_ids
-            and not (current_scene_ids & piece_scene_ids)
-        )
-        if crosses_scene and current_units >= min_chars:
-            flush()
-        if current and current_units >= min_chars and current_units + units > max_chars:
-            flush()
-        current.append(piece)
-        current_scene_ids.update(piece_scene_ids)
-        current_units += units
-        if current_units >= max_chars:
-            flush()
-    flush()
-    return chunks
-
-
-def _truncate_at_sentence(text, max_chars):
-    """在句子边界截断，不产生残句。max_chars 按有效字符计（不含标点空白）。"""
-    if _text_char_count(text) <= max_chars:
-        return text
-    eff = 0
-    cutoff = len(text)
-    for i, ch in enumerate(text):
-        eff += 1 if _text_char_count(ch) else 0
-        if eff > max_chars:
-            cutoff = i + 1
-            break
-    idx = max(text[:cutoff].rfind(sep) for sep in ["。", "！", "？", "!", "?"])
-    if idx > 0:
-        return text[: idx + 1]
-    idx = max(text[:cutoff].rfind(sep) for sep in ["，", "、", "；", ","])
-    if idx > 3:
-        return text[:idx] + "。"
-    return ""
-
-
-def _char_bigrams(text):
-    return {text[i : i + 2] for i in range(len(text) - 1) if text[i : i + 2].strip()}
-
-
-def _post_dedup_narration(narration):
-    """去除相邻相似解说段（bigram 重叠 >60% 则合并）。"""
-    if len(narration) < 2:
-        return narration
-    result = [narration[0]]
-    for seg in narration[1:]:
-        prev = result[-1]
-        set_a, set_b = _char_bigrams(prev["narration"]), _char_bigrams(seg["narration"])
-        if not set_a or not set_b:
-            result.append(seg)
-            continue
-        overlap = len(set_a & set_b) / min(len(set_a), len(set_b))
-        # Only merge near-identical adjacent beats. Short Chinese beats share many
-        # bigrams by chance, so a low threshold collapses intentional parallel beats
-        # ("他不再试探" / "他直接赌上全力") and silently drops density below target.
-        if overlap > 0.6:
-            # Validation is also the handoff boundary for renderer metadata: keep the
-            # overlays authored on either merged beat.
-            merged_overlays = copy.deepcopy(
-                prev.get("visual_overlays", []) + seg.get("visual_overlays", [])
-            )
-            if len(seg["narration"]) > len(prev["narration"]):
-                prev["narration"] = seg["narration"]
-            prev["end"] = seg["end"]
-            prev["pause_after_ms"] = seg["pause_after_ms"]
-            if merged_overlays:
-                prev["visual_overlays"] = merged_overlays
-            log(f"  去重合并: {prev['start']:.0f}-{prev['end']:.0f}s")
-        else:
-            result.append(seg)
-    removed = len(narration) - len(result)
-    if removed:
-        log(f"  去重: {len(narration)} → {len(result)} 段 (合并 {removed} 段)")
-    return result
+def _find_scene_for_midpoint(scenes_analysis, start, end):
+    mid = (start + end) / 2
+    for scene in scenes_analysis:
+        if scene["start"] <= mid <= scene["end"]:
+            return scene
+    return None
 
 
 def _scene_available_seconds(start, end):
@@ -251,51 +38,15 @@ def _recommended_char_budget(start, end):
     return int(_scene_available_seconds(start, end) * effective_rate)
 
 
-def _find_scene_for_midpoint(scenes_analysis, start, end):
-    mid = (start + end) / 2
-    for scene in scenes_analysis:
-        if scene["start"] <= mid <= scene["end"]:
-            return scene
-    return None
-
-
-def _normalise_narration_segment(seg):
-    """Normalize one lint-validated narration segment for the full-mode rewrite.
-
-    Authored timing is a delivery contract: scene boundaries are approximate
-    visual-analysis buckets, so start/end are never clamped here.
-    """
-    item = {
-        "start": round(seg["start"], 2),
-        "end": round(seg["end"], 2),
-        "narration": str(seg["narration"]).strip(),
-        "pause_after_ms": int(seg.get("pause_after_ms", CONFIG["breath_ms"])),
-        "overlaps_speech": bool(seg.get("overlaps_speech", True)),
-    }
-    for optional_key in (
-        "source_start",
-        "source_end",
-        "source_clip_id",
-        "source_entry_policy",
-        "source_entry_reason",
-    ):
-        if optional_key in seg:
-            item[optional_key] = seg[optional_key]
-    # carry the per-beat emotion/tone tag (MiMo TTS instruct) through lint untouched
-    if seg.get("emotion"):
-        item["emotion"] = seg["emotion"].strip()
-    # Renderer-owned metadata survives the validation rewrite; the recap orchestrator
-    # filters supported overlay kinds later.
-    if "visual_overlays" in seg:
-        item["visual_overlays"] = copy.deepcopy(seg["visual_overlays"])
-    return item
-
-
-def _clean_narration_punctuation(text):
-    text = re.sub(r"\s+", " ", text).strip()
-    text = re.sub(r'[，：、；,]["\']?[。！？]', "。", text)
-    return re.sub(r'["\']。$', "。", text)
+# Lint-only realism on top of the brief's budget. Every block is one TTS utterance, and the
+# provider pads each utterance with edge silence that voiceover keeps and assemble must
+# place inside the window. Measured on 98 MiMo blocks from real runs (-40 dBFS): 0.40 /
+# 0.54 / 0.62 s at p10 / p50 / p90 before the 1.15x narration atempo, i.e. about 0.47 s
+# placed. On a 2-3 s window that is a fifth of the room, so without it a short window
+# passed lint and failed in assemble as no_safe_fit after TTS was billed.
+TTS_UTTERANCE_OVERHEAD_SECONDS = 0.45
 
 
-def _overlap_seconds(start, end, other_start, other_end):
-    return max(0.0, min(end, other_end) - max(start, other_start))
+def _lint_char_budget(start, end):
+    """The brief's budget for the window minus one utterance's TTS edge silence."""
+    return _recommended_char_budget(start, end - TTS_UTTERANCE_OVERHEAD_SECONDS)

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

@@ -61,7 +61,11 @@ def _text_units(text: str) -> int:
 def _normalise_segments(payload: list[dict[str, Any]], *, source: str) -> list[dict[str, Any]]:
     key = "narration" if source == "narration" else "text"
     segments: list[dict[str, Any]] = []
+    # `index` is the item's position in the file as written (non-objects included), so a
+    # blocker points at the same entry the author sees there.
     for idx, item in enumerate(payload):
+        if not isinstance(item, dict):
+            continue
         text = str(item.get(key, "")).strip()
         if text:
             segments.append({"source": source, "index": idx, "text": text})
@@ -77,46 +81,27 @@ def _load_original_subtitles(work_dir: Path | None) -> list[dict[str, Any]]:
     return _normalise_segments(json.loads(path.read_text(encoding="utf-8")), source="original_subtitles")
 
 
-def _style_card_requirement(work_dir: Path | None) -> tuple[bool, str]:
-    """Read the explicit requirements contract; workspaces without one are advisory-only."""
-    if work_dir is None:
-        return False, "legacy_default"
-    path = work_dir / "deslop_qc_requirements.json"
-    if not path.exists():
-        return False, "legacy_default"
-    data = json.loads(path.read_text(encoding="utf-8"))
-    return data["style_card_required"], "deslop_qc_requirements.json"
-
-
-def _style_card_issue(work_dir: Path | None, required: bool) -> dict[str, Any] | None:
+def _style_card_issue(work_dir: Path | None) -> dict[str, Any] | None:
+    """A missing or empty style_card.json is always advisory, never a render blocker."""
     if work_dir is None:
         return None
-    severity = "blocker" if required else "advisory"
     path = work_dir / "style_card.json"
     if not path.exists():
         return {
-            "severity": severity,
+            "severity": "advisory",
             "code": "missing_style_card",
             "source": "style_card",
             "index": None,
-            "message": (
-                "style_card.json is required by this expression/packaging run but is missing"
-                if required else
-                "style_card.json is absent; legacy/migration workspaces may continue, but new expression-special runs should author it"
-            ),
+            "message": "style_card.json is absent; legacy/migration workspaces may continue, but new expression-special runs should author it",
         }
     data = json.loads(path.read_text(encoding="utf-8"))
     if not isinstance(data, dict) or not data:
         return {
-            "severity": severity,
+            "severity": "advisory",
             "code": "malformed_style_card",
             "source": "style_card",
             "index": None,
-            "message": (
-                "style_card.json is required but empty or not a JSON object"
-                if required else
-                "style_card.json is present but empty or not a JSON object; treat as migration warning unless the run requires it"
-            ),
+            "message": "style_card.json is present but empty or not a JSON object; treat as migration warning",
         }
     return None
 
@@ -139,10 +124,9 @@ def analyze_deslop_qc(narration: list[dict[str, Any]], *, work_dir: str | Path |
     blockers: list[dict[str, Any]] = []
     advisories: list[dict[str, Any]] = []
 
-    required, requirement_source = _style_card_requirement(work_path)
-    style_issue = _style_card_issue(work_path, required)
+    style_issue = _style_card_issue(work_path)
     if style_issue:
-        (blockers if style_issue["severity"] == "blocker" else advisories).append(style_issue)
+        advisories.append(style_issue)
 
     all_text = "\n".join(seg["text"] for seg in segments)
     total_units = max(1, _text_units(all_text))
@@ -189,8 +173,6 @@ def analyze_deslop_qc(narration: list[dict[str, Any]], *, work_dir: str | Path |
         "ok": not blockers,
         "contract": CONTRACT,
         "scanner": "deslop_qc.py",
-        "style_card_required": required,
-        "style_card_requirement_source": requirement_source,
         "blocker_count": len(blockers),
         "advisory_count": len(advisories),
         "blockers": blockers,

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

@@ -0,0 +1,125 @@
+"""Where an interrupting narration block may be told to move.
+
+`interrupts_source_sentence` suggests a sentence-end anchor the whole block can shift to.
+These helpers keep that suggestion between the block's neighbours and clear of every other
+block, and decide when a block is a back-to-back handoff that needs no entry check.
+"""
+
+import math
+
+
+def _is_number(value):
+    return (
+        isinstance(value, (int, float))
+        and not isinstance(value, bool)
+        and math.isfinite(value)
+    )
+
+
+# A narration block that starts within this gap after another block's end is a
+# back-to-back handoff: the source track is never exposed between the two.
+CONNECTED_HANDOFF_SECONDS = 0.15
+# A suggested entry farther than this from the authored one moves the block off the
+# pictures it was written for; past it the author must rethink the block instead.
+SUGGESTED_ANCHOR_MAX_SHIFT_SECONDS = 10.0
+
+
+def _shift_is_clear(new_start, duration, other_spans):
+    """The block moved whole to new_start neither overlaps nor abuts another block."""
+    new_end = new_start + duration
+    gap = CONNECTED_HANDOFF_SECONDS
+    return all(
+        new_end < other_start - gap or new_start > other_end + gap
+        for other_start, other_end in other_spans
+    )
+
+
+def _nearest_safe_anchor(start, end, anchors, other_spans, window=(None, None)):
+    """The anchor closest to `start` the whole block can move to (duration kept) without
+    overlapping or abutting another block or leaving `window`, within
+    SUGGESTED_ANCHOR_MAX_SHIFT_SECONDS; a later anchor wins a tie. None when none qualifies.
+
+    `window` is the open (low, high) range the moved block must sit strictly inside: the
+    neighbours' ends with the handoff gap, so a block never jumps over a neighbour (story
+    order) and two adjacent blocks never get colliding suggestions. Either side may be None.
+    """
+    duration = end - start
+    low, high = window
+    candidates = [
+        anchor
+        for anchor in anchors
+        if abs(anchor["time"] - start) <= SUGGESTED_ANCHOR_MAX_SHIFT_SECONDS
+        and anchor["time"] >= 0
+        and (low is None or anchor["time"] > low)
+        and (high is None or anchor["time"] + duration < high)
+        and _shift_is_clear(anchor["time"], duration, other_spans)
+    ]
+    if not candidates:
+        return None
+    return min(candidates, key=lambda anchor: (abs(anchor["time"] - start), -anchor["time"]))
+
+
+def _valid_span(seg):
+    """(start, end) of a block with a usable numeric window, else None."""
+    if not isinstance(seg, dict):
+        return None
+    start, end = seg.get("start"), seg.get("end")
+    if _is_number(start) and _is_number(end) and end > start:
+        return start, end
+    return None
+
+
+def _other_block_spans(narration, idx):
+    """(start, end) of every other block with a usable numeric window."""
+    return [
+        span
+        for other_idx, other in enumerate(narration)
+        if other_idx != idx and (span := _valid_span(other))
+    ]
+
+
+# Clip/timeline edges are allowed positions; the open window bound sits this far outside.
+_EDGE_EPSILON = 1e-6
+
+
+def _suggestion_window(narration, idx, suggested_spans, limits=(None, None)):
+    """Open (low, high) range a suggested move of block `idx` must stay strictly inside.
+
+    Bounded by the previous and next valid blocks (narration is chronological) with the
+    handoff gap. The previous block counts at both its authored and its own suggested
+    window, so applying any subset of the suggestions keeps adjacent blocks apart and in
+    order. `limits` is the closed (first, last) range the block must stay in: its clip in
+    cut mode, the output duration in cut_output; either side may be None.
+    """
+    gap = CONNECTED_HANDOFF_SECONDS
+    low = high = None
+    for prev_idx in range(idx - 1, -1, -1):
+        span = _valid_span(narration[prev_idx])
+        if span:
+            low = max(span[1], suggested_spans.get(prev_idx, span)[1]) + gap
+            break
+    for next_idx in range(idx + 1, len(narration)):
+        span = _valid_span(narration[next_idx])
+        if span:
+            high = span[0] - gap
+            break
+    first, last = limits
+    if first is not None:
+        low = max(x for x in (low, first - _EDGE_EPSILON) if x is not None)
+    if last is not None:
+        high = min(x for x in (high, last + _EDGE_EPSILON) if x is not None)
+    return low, high
+
+
+def _has_connected_predecessor(narration, idx, start):
+    """A back-to-back narration handoff (<=150ms gap) does not expose the source track,
+    so the next TTS block is not a new source-speech entry."""
+    for other_idx, other in enumerate(narration):
+        if other_idx == idx or not isinstance(other, dict):
+            continue
+        other_start, other_end = other.get("start"), other.get("end")
+        if not _is_number(other_start) or not _is_number(other_end):
+            continue
+        if other_start < start and -0.001 <= start - other_end <= CONNECTED_HANDOFF_SECONDS:
+            return True
+    return False

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

@@ -7,13 +7,11 @@ import re
 
 EVIDENCE_CONTRACT_VERSION = 1
 
-COVERAGE_POLICY_VERSION = "coverage_policy_v1"
-
 
 def _safe_time(item, key, default=0.0):
     try:
         value = float(item.get(key, default))
-    except (AttributeError, TypeError, ValueError):
+    except (TypeError, ValueError):
         return default
     return value if math.isfinite(value) else default
 
@@ -85,7 +83,6 @@ def coverage_policy_v1(
     duration = _overall_duration(scenes, asr_result, narration)
     if duration <= 0:
         return {
-            "coverage_policy_version": COVERAGE_POLICY_VERSION,
             "selected_ranges": [],
             "dropped_ranges": [],
             "dropped_range_count": 0,
@@ -162,7 +159,6 @@ def coverage_policy_v1(
     for r in merged + dropped:
         r.pop("priority", None)
     return {
-        "coverage_policy_version": COVERAGE_POLICY_VERSION,
         "selected_ranges": merged,
         "dropped_ranges": dropped,
         "dropped_range_count": len(dropped),
@@ -276,13 +272,11 @@ def _research_context_items(research):
 
 
 def filter_evidence_by_ranges(vlm_analysis, asr_result, ranges, *, timeline="source"):
-    """Pure compatibility seam: collect visual/ASR evidence items inside ranges."""
+    """Pure: collect visual/ASR evidence items inside ranges."""
     clock = "output" if timeline == "cut_output" else "source"
     items = []
     dropped = {"visual": 0, "asr": 0}
     for i, scene in enumerate(vlm_analysis or []):
-        if not isinstance(scene, dict):
-            continue
         start = _safe_time(scene, "start")
         end = _safe_time(scene, "end", start)
         if end <= start or not _in_ranges(start, end, ranges):
@@ -309,8 +303,6 @@ def filter_evidence_by_ranges(vlm_analysis, asr_result, ranges, *, timeline="sou
                 item[k] = scene.get(k)
         items.append(item)
     for i, seg in enumerate(asr_result or []):
-        if not isinstance(seg, dict):
-            continue
         text = str(seg.get("text", "")).strip()
         if not text:
             continue
@@ -346,22 +338,6 @@ def filter_evidence_by_ranges(vlm_analysis, asr_result, ranges, *, timeline="sou
     }
 
 
-def build_review_coverage_metadata(bundle):
-    """Summarize a build_evidence_bundle() bundle's coverage contract."""
-    coverage = bundle["coverage"]
-    metadata = bundle["metadata"]
-    return {
-        "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 build_evidence_bundle(
     vlm_analysis,
     asr_result,