@oh-story/dsh 0.1.12 → 0.1.14

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

@@ -5,6 +5,9 @@ description: >
  宣发标题、花字修订和外部文案回填。普通策划输入 work_dir 的 agent_narration_brief.md 与
  vlm_analysis.json；文案返修输入当前成片的工程与内容证据。策划输出 recap_story_plan.json、visual_audio_board.json、
  可选 style_card.json、cut 模式需要的 clip_plan.json，以及通过校验的 narration.json；仅宣发文案任务交付提案或回填既有包装计划。
+ 外发说明：只有建议型评审 review.py 联网，它把旁白稿全文与理解证据、策划文件的文字摘录发到 MiMo chat 接口
+ （MIMO_API_KEY / MIMO_API_URL，不发视频、图片或音频）；单独使用时只在显式执行时运行，端到端编排默认在 TTS 前运行一次，
+ 可用 --no-review-narration / REVIEW_NARRATION=0 关闭（严格评审开启时除外）；validate.py 与 lint 仅在本地运行。
  触发词：解说词、写解说、视频旁白、宣发标题、花字修订、文案回填、
  narration script、写稿、解说文案、剪辑思路、导演思路。
 ---
@@ -23,7 +26,7 @@ description: >
 4. 声音/旁白编辑
 5. 第一次观看的观众
 
-Agent 先记录简洁决定，再写时间线产物。`validate.py` 负责对理解索引做机械校验；full 模式默认还会执行预算整理并计算旁白的原声重叠。已有批准稿应加 `--preserve-approved-text`，保留段落顺序、数量、时间、文本、停顿和扩展元数据，仅允许依据现有声音证据更新 `overlaps_speech`。
+Agent 先记录简洁决定，再写时间线产物。`validate.py` 负责对理解索引做机械校验，从不改写 Agent 的稿子：段落顺序、数量、时间、文本、停顿和扩展元数据原样保留，只依据现有声音证据回写实测的 `overlaps_speech`。文本装不下时间窗、段落未按时间排序等问题以 error 退回给 Agent 修改。
 
 下面的 `scripts/...` 均相对于本技能目录。若执行器从仓库根目录启动，请给脚本路径加上本技能的绝对目录。
 
@@ -37,15 +40,39 @@ Agent 先记录简洁决定，再写时间线产物。`validate.py` 负责对理
 
 REVISION 先明确本轮修改项与冻结项，再编辑对应层：表达、口语节奏、字幕反馈更新 `style_card.json`；镜头、入出点、表演和声音分工更新 `visual_audio_board.json`；只有观众承诺、POV、主线或 beat 改变时才更新 `recap_story_plan.json`。被删除的镜头、原声或文案也要从相关计划中删除，不能保留过期锚点。不要把看片修改重新做成一次 CREATE。
 
-## 2. 读取素材并确认状态
+## 2. 远程调用与数据外发
+
+本技能只有一个脚本会联网：`review.py`（§7.1 的建议型语义评审）。其余全部在本地运行：`validate.py` 及其 lint、去 AI 味检查只读写 `work_dir` 里的文件，不发任何网络请求；策划与写稿由 Agent 直接读写 `work_dir` 完成。
+
+`review.py` 发给谁：
+
+- MiMo 的 OpenAI 兼容 chat 接口 `<MIMO_API_URL>/chat/completions`，用 `MIMO_API_KEY` 认证，模型为 `MIMO_MODEL`（默认 `mimo-v2.5`）。未设 `MIMO_API_URL` 时，按量计费 key 发往 `https://api.xiaomimimo.com/v1`，`tp-` 开头的 Token Plan key 发往 `MIMO_TOKEN_PLAN_CLUSTER` 选定的 token-plan 集群（默认 `https://token-plan-cn.xiaomimimo.com/v1`）。
+- 未设 `MIMO_API_KEY` 时直接退出，不构造也不发送任何请求。
+
+`review.py` 发送什么（只有文字，不发视频、帧图片或音频文件）：
+
+- `narration.json` 全部旁白段的时间与文字。
+- 理解索引的文字证据：开头、中段、结尾、长空档与各旁白时间窗附近选出的时间段内，`vlm_analysis.json` 的场景描述与 `frame_facts` 文字，以及对白转写（有 `asr_clean.json` 时用它，否则 `asr_result.json`）。
+- `background_research.json` 的梗概、角色、关系与剧情线摘录。
+- 存在时附上 `packaging_plan.json`、`recap_story_plan.json`、`visual_audio_board.json`、`style_card.json`（各截前 3000 字）和 `original_subtitles.json` 的原声字幕文字。
+- 内容较长时分块，每块一次请求；返回的意见只写回本地 `narration_review.json` / `narration_review.md`。
+
+何时运行、怎样关闭：
+
+- 单独使用本技能时，`review.py` 只在用户或 Agent 显式执行它时运行；不执行它就没有任何外发。用户不希望稿件离开本机时，不要运行它，改为人工复核后直接跑 `validate.py`。
+- 端到端编排默认在 TTS 前自动调用一次这项评审，失败不阻断；关闭方式是编排入口的 `--no-review-narration` 或环境变量 `REVIEW_NARRATION=0`。若同时开启了严格评审（`--require-narration-review` 或 `REQUIRE_NARRATION_REVIEW=1`），评审必须运行，关闭开关不生效。
+- 评审是建议型的：只写报告，从不改写 `narration.json`；是否修改由 Agent 或用户决定。
+
+## 3. 读取素材并确认状态
 
 首先阅读：
 
 - `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` 里有）：另一部成片拆出的可迁移方法与节奏数值，用法见 §4。
 
 full 模式使用原片时间。cut 模式第一阶段只写 `clip_plan.json`；`edited_source.mp4` 产生后，第二阶段才按输出时间写 `narration.json`。
 
@@ -58,7 +85,7 @@ full 模式使用原片时间。cut 模式第一阶段只写 `clip_plan.json`；
 
 必须确认旁白没有跨越错误剪辑边界，也没有落进已删除区间。整个判断只依赖 `work_dir` 产物。
 
-## 3. 制定创作方案
+## 4. 制定创作方案
 
 先阅读 `references/creative-editing-playbook.md`，再按创作控制模式写或更新工作产物：
 
@@ -68,7 +95,9 @@ full 模式使用原片时间。cut 模式第一阶段只写 `clip_plan.json`；
 
 只记录决定、证据锚点、被放弃的备选方案和简短理由，不写冗长思维过程。
 
-### 3.1 导演判断
+若 `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": "…"}]`。没有这个文件就跳过本段。
+
+### 4.1 导演判断
 
 锁定：
 
@@ -79,11 +108,11 @@ full 模式使用原片时间。cut 模式第一阶段只写 `clip_plan.json`；
 - 隐瞒与揭示
 - 结尾余味
 
-### 3.2 故事编辑
+### 4.2 故事编辑
 
 CREATE 比较两个真正可行的结构后选择一个；DIRECTED / REVISION 沿用用户指定或已确认的结构，除非最新反馈明确改变故事方向。每个 beat 至少改变一项：知识、权力、目标、关系、情绪或风险。若删除后因果、人物和情绪都没有损失，该 beat 通常不应保留。
 
-### 3.3 画面剪辑
+### 4.3 画面剪辑
 
 选择具体时刻，而不是只选择事件。比较：
 
@@ -94,7 +123,7 @@ CREATE 比较两个真正可行的结构后选择一个；DIRECTED / REVISION
 
 在不破坏理解的前提下晚进早出，同时保留不可替代的表演、停顿、失误、动作声和完整台词。
 
-### 3.4 声音与旁白分工
+### 4.4 声音与旁白分工
 
 先指定 `audio_owner`，再写字。旁白只允许承担以下 `narration_job`：
 
@@ -107,7 +136,7 @@ CREATE 比较两个真正可行的结构后选择一个；DIRECTED / REVISION
 
 画面、原声或沉默已经足够时使用 `none`，不要默认铺旁白。
 
-### 3.5 cut 模式第一阶段
+### 4.5 cut 模式第一阶段
 
 cut 模式先根据 `recap_story_plan.json` 与 `visual_audio_board.json` 写原片时间的 `clip_plan.json`，此时不要写 `narration.json`：
 
@@ -132,7 +161,7 @@ beat_id | function | change | POV | preferred moment | 入点 | 出点
 
 片段顺序必须构成一条完整故事线，而不是无序高光。可使用 0–1 个 cold open，随后回到因果清楚的 setup → turn → escalation → payoff。片段长度服从具体时刻，不使用统一秒数模板；片尾必须保留完整台词或动作。密集 scene-change 候选的来源判断与处理规则由剪辑阶段定义，写计划时遵循同一规则，不制造人工闪切。
 
-## 4. 撰写旁白
+## 5. 撰写旁白
 
 full 模式直接按原片时间写；cut 第二阶段先查看 `edited_source.mp4` 与剪后故事板，补充 `visual_audio_board.json` 的输出时间并重新确认 `audio_owner` / `narration_job`，再按输出时间写：
 
@@ -153,25 +182,25 @@ 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` |
 | `emotion` | 整个解说块的 MiMo TTS 情绪/语气标签 |
 
-### 4.1 写作规则
+### 5.1 写作规则
 
 1. **先有 `narration_job`，后有句子**：没有明确任务就不写；旁白不是默认音轨。
 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 文本先保证听感连续，字幕再按阅读宽度拆分，不能反过来把朗读稿切碎。
 9. **避免模板化纠偏**：“不是 A，而是 B”只在确实存在一个观众可能相信、而素材又要纠正的判断时使用。它不是禁句，但不能靠先否定再肯定制造假洞察；优先直接写人物的动作、因果和后果。
 
-### 4.2 解说结构
+### 5.2 解说结构
 
 - **钩子**：提出正文会真实兑现的问题或利害，不用无关留存话术。
 - **主线**：围绕选定 POV 与主线推进，不在每个场景重新开篇。
@@ -180,7 +209,7 @@ full 模式直接按原片时间写；cut 第二阶段先查看 `edited_source.m
 - **收尾**：回答或有意转化开头问题，留下明确余味。
 - **衔接**：旁白块与相邻原声属于同一个 beat，前者铺垫、后者呈现、下一块承接。
 
-### 4.3 原声留白字幕
+### 5.3 原声留白字幕
 
 可选写 `original_subtitles.json`，使用成片输出时间：
 
@@ -190,7 +219,7 @@ full 模式直接按原片时间写；cut 第二阶段先查看 `edited_source.m
 
 只写留白中实际听得到的台词，订正 ASR 错字与人名，每条尽量控制在一行；被旁白盖住或已经剪掉的句子不要写。省略时，合成阶段会使用保守的 ASR 映射兜底，并在成片中用 `「」` 区分原声对白与旁白。
 
-## 5. 创作自审
+## 6. 创作自审
 
 在调用 LLM 评审前做以下**反事实检查**：
 
@@ -206,19 +235,19 @@ full 模式直接按原片时间写；cut 第二阶段先查看 `edited_source.m
 
 REVISION 还要逐项确认：用户点名的问题已经改变，未点名的冻结项没有意外变化，相关 `style_card.json` / `visual_audio_board.json` 中不存在旧镜头或旧表达。除非用户要求备选版本，不额外扩展新方向。
 
-## 6. 评审与校验
+## 7. 评审与校验
 
-### 6.1 建议型语义评审
+### 7.1 建议型语义评审
 
 ```bash
-python3 scripts/review.py --work-dir <work_dir>
+python3 scripts/review.py --work-dir <work_dir>   # 会联网：外发内容与关闭方式见 §2
 ```
 
 评审会自动识别 cut 模式，并在存在已校验剪辑计划时按输出时间线核对；`--timeline source` 可强制使用原片时间。打开 `narration_review.md`，逐项处理 `error`，尤其是 `category=hallucination`。
 
 重复修改并评审，直到：
 
-- `verdict` 为 `PASS` / `OK` 且没有 `error`；或
+- `verdict` 为 `PASS` 且没有 `error`；或
 - 对仍保留的问题做明确 override。
 
 覆盖决定追加到 `work_dir/narration_review_override.md`：
@@ -233,19 +262,19 @@ python3 scripts/review.py --work-dir <work_dir>
 
 `review.py` 本身只写报告，默认调用策略为建议型、失败开放；若调用方显式开启严格评审，事实矛盾、残句、解析失败或评审不可用可在 TTS 前阻断。覆盖记录只用于审计，`review.py` / `validate.py` 不读取它。
 
-### 6.2 确定性硬校验
+### 7.2 确定性硬校验
 
 ```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 中的数量只能当上限：宁可少写、写实，也不要为凑数复述画面。
 
-## 7. 能力边界
+## 8. 能力边界
 
 - 不运行 ASR / VLM，不合成 TTS，不渲染视频；只消费视频理解索引。
+- 唯一的远程调用是 `review.py` 的 MiMo 文字评审（见 §2）；`validate.py` 与 lint 只在本地运行。
 - 平台研究仅用于明确的宣发任务；不替代当前片内事实，也不默认改变解说和剪辑。

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,