@oh-story/dsh 0.1.12 → 0.1.13

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

@@ -1,6 +1,7 @@
 """Load measured source-speech evidence and classify narration ownership."""
 
 import json
+import re
 from pathlib import Path
 
 from lib import CONFIG, file_identity
@@ -10,16 +11,93 @@ def _empty_evidence(mode):
     return {
         "anchors": [],
         "speech_spans": [],
+        "dialogue_spans": [],
         "quiet_windows": [],
         "require_measured": mode == "cut_output",
     }
 
 
+# Interjections and common ASR artifacts on screams/music. A window whose text is only these
+# is not dialogue at a clip edge or narration entry; real short lines such as "救我！" still are.
+# Same copy in video-cut, video-script and video-assemble (parity-tested by function).
+_NON_DIALOGUE_TOKENS = frozenset(
+    "啊 嗯 哼 哦 呃 唉 嘿 呦 哈 呀 hi yeah ok okay oh uh ah hmm".split()
+)
+_NON_DIALOGUE_CJK = frozenset("啊嗯哼哦呃唉嘿呦哈呀")
+# Lines cross 15s ASR window edges (a line may run 13.2–15.4 while its window ends at 15.0),
+# so an interjection-only window next to real dialogue keeps this much of its shared edge.
+_INTERJECTION_GUARD_SECONDS = 1.0
+
+
+def _interjection_only(text):
+    tokens = [token for token in re.split(r"[\W_]+", text.lower()) if token]
+    # Punctuation-only rows ("……", "？") are often ASR for unintelligible speech: keep them.
+    return bool(tokens) and all(
+        token in _NON_DIALOGUE_TOKENS or set(token) <= _NON_DIALOGUE_CJK for token in tokens
+    )
+
+
+def _dialogue_speech_spans(rows):
+    """Merged dialogue spans from timed ASR rows.
+
+    A row holding only interjections ("啊！", "Hi.") is not dialogue, except a
+    `_INTERJECTION_GUARD_SECONDS` guard on an edge it shares with a dialogue row. A row
+    whose text is empty or whitespace (ASR heard no words) is timing-only evidence: it is
+    skipped here and guards nothing. A row with no `text` field is measured timing whose
+    words are unknown and counts as dialogue.
+    """
+    rows = sorted(
+        (
+            {
+                "start": row["start"],
+                "end": row["end"],
+                "dialogue": not _interjection_only(row.get("text", "")),
+            }
+            for row in rows
+            if "text" not in row or row["text"].strip()
+        ),
+        key=lambda row: (row["start"], row["end"]),
+    )
+    spans = []
+    for idx, row in enumerate(rows):
+        if row["dialogue"]:
+            spans.append({"start": row["start"], "end": row["end"]})
+            continue
+        before = rows[idx - 1] if idx > 0 else None
+        after = rows[idx + 1] if idx + 1 < len(rows) else None
+        if before and before["dialogue"] and row["start"] - before["end"] <= 0.05:
+            end = min(row["end"], row["start"] + _INTERJECTION_GUARD_SECONDS)
+            spans.append({"start": row["start"], "end": end})
+        if after and after["dialogue"] and after["start"] - row["end"] <= 0.05:
+            start = max(row["start"], row["end"] - _INTERJECTION_GUARD_SECONDS)
+            spans.append({"start": start, "end": row["end"]})
+    spans.sort(key=lambda row: (row["start"], row["end"]))
+    merged = []
+    for span in spans:
+        if merged and span["start"] <= merged[-1]["end"] + 0.05:
+            merged[-1]["end"] = max(merged[-1]["end"], span["end"])
+        else:
+            merged.append(span)
+    return merged
+
+
 def _read_json(path):
     """JSON artifact, or None when the optional file was never written."""
     return json.loads(path.read_text(encoding="utf-8")) if path.exists() else None
 
 
+def _source_asr_rows(work_dir):
+    """Cleaned ASR segments (asr_clean.json) when present, else raw asr_result.json.
+
+    Same precedence as video-cut's edge gate and video-assemble's entry check, so one
+    transcript decides lint, cut and assemble verdicts. Blank-text rows are timing-only
+    evidence (ASR heard no words) and are not source speech.
+    """
+    clean = _read_json(work_dir / "asr_clean.json")
+    rows = clean["segments"] if clean is not None else _read_json(work_dir / "asr_result.json")
+    return [row for row in rows or [] if row["text"].strip()]
+
+
 def _output_payload_is_current(payload, work_dir):
     plan_path = Path(work_dir) / "clip_plan_validated.json"
     return (
@@ -38,9 +116,7 @@ def load_source_sentence_evidence(work_dir, mode="full"):
         payload = _read_json(work_dir / "speech_boundary_anchors.json") or {
             "sentence_anchors": []
         }
-        speech_spans = [
-            row for row in _read_json(work_dir / "asr_result.json") or [] if row["text"]
-        ]
+        speech_spans = _source_asr_rows(work_dir)
         quiet_windows = [
             row
             for row in _read_json(work_dir / "silence_periods.json") or []
@@ -54,14 +130,22 @@ def load_source_sentence_evidence(work_dir, mode="full"):
             payload = {"sentence_anchors": [], "speech_spans": [], "quiet_windows": []}
         speech_spans = payload["speech_spans"]
         quiet_windows = payload["quiet_windows"]
+    # `boundary_use` (schema 2) keeps coarse-ASR estimates usable as `unverified`; schema-1
+    # anchors (no `boundary_use`) were all coarse estimates: high/medium are `unverified`.
     anchors = [
         anchor
         for anchor in payload["sentence_anchors"]
-        if anchor["confidence"] in {"high", "medium"}
+        if (
+            anchor.get("boundary_use")
+            or ("unverified" if anchor["confidence"] in {"high", "medium"} else "none")
+        )
+        != "none"
     ]
     return {
         "anchors": sorted(anchors, key=lambda item: item["time"]),
         "speech_spans": speech_spans,
+        # Entry ownership only: an interjection-only window has no sentence to interrupt.
+        "dialogue_spans": _dialogue_speech_spans(speech_spans),
         "quiet_windows": quiet_windows,
         "require_measured": mode == "cut_output",
     }
@@ -124,7 +208,7 @@ def entry_overlaps_source_speech(start, evidence, *, authored_overlap=True, tole
         return False
     if any(
         row["start"] - tolerance <= start < row["end"] - tolerance
-        for row in evidence["speech_spans"]
+        for row in evidence["dialogue_spans"]
     ):
         return True
     if evidence["speech_spans"]:

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

@@ -2,9 +2,9 @@
 """video-script validation entrypoint.
 
 Validate an agent-written narration.json against the local understanding index.
-Legacy full mode performs budget cleanup/deduplication and derives speech ownership.
-Protected mode keeps the approved timeline and metadata exact except for measured
-``overlaps_speech`` ownership.
+Validation never rewrites the agent's text, timing, order or metadata. Full-mode text
+that does not fit its window fails lint and goes back to the author. full and cut_output
+persist only the measured ``overlaps_speech`` ownership.
 """
 
 import argparse
@@ -12,13 +12,9 @@ import json
 import math
 from pathlib import Path
 
-from lib import CONFIG, log
-from narration_lint import (
-    _validate_narration_budget,
-    validate_narration_or_raise,
-)
+from lib import log
+from narration_lint import NarrationLintError, validate_narration_or_raise
 from speech_ownership import measure_narration_speech_ownership
-from timeline_fusion import _align_narration_to_quiet
 
 
 def _load(path):
@@ -57,16 +53,16 @@ def _validate_output_timeline_bounds(narration, duration, tolerance=0.05):
         start, end = seg["start"], seg["end"]
         if end <= -tolerance or start >= duration + tolerance:
             problems.append(
-                f"segment {idx} [{start:.3f},{end:.3f}] fully outside output_duration={duration:.3f}"
+                f"段 {idx + 1} [{start:.3f},{end:.3f}] fully outside output_duration={duration:.3f}"
             )
             continue
         if start < -tolerance:
             problems.append(
-                f"segment {idx} start={start:.3f} before output timeline (output_duration={duration:.3f})"
+                f"段 {idx + 1} start={start:.3f} before output timeline (output_duration={duration:.3f})"
             )
         if end > duration + tolerance:
             problems.append(
-                f"segment {idx} end={end:.3f} exceeds output_duration={duration:.3f}"
+                f"段 {idx + 1} end={end:.3f} exceeds output_duration={duration:.3f}"
             )
     if problems:
         raise SystemExit(
@@ -76,8 +72,17 @@ def _validate_output_timeline_bounds(narration, duration, tolerance=0.05):
 
 
 def main():
+    try:
+        _validate(_parse_args())
+    except NarrationLintError as exc:
+        # A lint failure is an ordinary result the author fixes from the summary,
+        # not a crash: exit non-zero with the summary only, no traceback.
+        raise SystemExit(str(exc)) from None
+
+
+def _parse_args():
     ap = argparse.ArgumentParser(
-        description="Validate + align agent-written narration.json."
+        description="Validate agent-written narration.json and measure speech ownership."
     )
     ap.add_argument("--work-dir", required=True)
     ap.add_argument("--mode", default="full", choices=["full", "cut", "cut_output"])
@@ -87,21 +92,16 @@ def main():
         default=None,
         help="cut_output: rendered edited_source.mp4 duration in seconds",
     )
-    ap.add_argument(
-        "--preserve-approved-text",
-        action="store_true",
-        help="validate approved narration without rewriting, truncating, merging, or reordering it",
-    )
-    args = ap.parse_args()
+    return ap.parse_args()
 
+
+def _validate(args):
     work_dir = Path(args.work_dir)
-    CONFIG["edit_mode"] = args.mode
     narration_path = work_dir / "narration.json"
     narration = _load(narration_path)
     if narration is None:
         raise SystemExit(f"缺少 {narration_path}；请先按 video-script 规则写解说词")
     vlm_analysis = _load(work_dir / "vlm_analysis.json")
-    silence_periods = _load(work_dir / "silence_periods.json") or []
     if args.mode == "cut_output":
         # Two-pass cut: narration is authored in OUTPUT time against edited_source.mp4 — there is
         # no source-time clip membership check. Lint the authored shape first, then derive speech
@@ -109,7 +109,7 @@ def main():
         # voiceover/assemble instead of trusting JSON.
         report = validate_narration_or_raise(
             narration, None, clip_plan=None, mode="cut_output", work_dir=work_dir,
-            require_chronological=args.preserve_approved_text,
+            output_duration=args.output_duration,
         )
         narration = measure_narration_speech_ownership(
             narration, work_dir, mode="cut_output"
@@ -139,21 +139,13 @@ def main():
         validate_narration_or_raise(
             narration, vlm_analysis, clip_plan=clip_plan, mode="cut", work_dir=work_dir
         )
-        if not args.preserve_approved_text:
-            narration = _validate_narration_budget(narration, vlm_analysis)
     else:
+        # Same contract as cut_output: lint the authored shape, then persist only the
+        # measured speech ownership (speech spans minus quiet windows).
         validate_narration_or_raise(
-            narration, vlm_analysis, clip_plan=None, mode="full", work_dir=work_dir,
-            require_chronological=args.preserve_approved_text,
+            narration, vlm_analysis, clip_plan=None, mode="full", work_dir=work_dir
         )
-        if args.preserve_approved_text:
-            narration = measure_narration_speech_ownership(
-                narration, work_dir, mode="full"
-            )
-        else:
-            narration = _align_narration_to_quiet(
-                narration, vlm_analysis, silence_periods
-            )
+        narration = measure_narration_speech_ownership(narration, work_dir, mode="full")
         narration_path.write_text(
             json.dumps(narration, ensure_ascii=False, indent=2), encoding="utf-8"
         )

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

@@ -36,7 +36,7 @@ description: >
 export MIMO_API_KEY=***
 ```
 
-ASR 使用 `mimo-v2.5-asr`；VLM 使用 `mimo-v2.5`。`--skip-asr` 可跳过对白转写，但完整理解仍需要 `MIMO_API_KEY` 运行 VLM。`--mimo-video-overview` 可开启按场景块的视频概览。
+ASR 使用 `mimo-v2.5-asr`；VLM 使用 `mimo-v2.5`。`--skip-asr` 可跳过对白转写，但完整理解仍需要 `MIMO_API_KEY` 运行 VLM。`--mimo-video-overview` 可开启按场景块的视频概览。未设置 key 时重跑会复用已缓存的转写、画面分析、概览与故事索引（key 决定的默认 endpoint 不参与比对）；需要请求模型的 consolidation 记为 `skipped_no_key`，不发请求。缓存对不上（例如复制 work_dir 时没保留文件时间）而已有转写时，运行停下并保留转写：用 `cp -p` / `cp -Rp` / `rsync -t` 保留时间重新复制，或设置 key 后重跑（会重新转写）。不要用 `--skip-asr` 绕过，它会把现有转写替换成 `[]`。
 
 若 `work_dir/background_research.json` 存在，本技能会把剧情梗概和角色名折入 VLM 上下文；`--context` 可补充一条简短提示。
 
@@ -45,19 +45,44 @@ ASR 使用 `mimo-v2.5-asr`；VLM 使用 `mimo-v2.5`。`--skip-asr` 可跳过对
 ## 4. 运行命令
 
 ```bash
-python3 scripts/understand.py <video> --work-dir <work_dir> \
-  [--context "节目名/角色名"] [--scene-threshold 0.1] [--skip-asr] [--mimo-video-overview] [--force]
+python3 scripts/understand.py <video> --work-dir <work_dir> [选项]
 ```
 
+| 选项 | 默认 | 作用 |
+|------|------|------|
+| `<video>` | 必填 | 源视频 |
+| `--work-dir` | 必填 | 产物目录；不存在时创建 |
+| `--context "..."` | 空 | 补充给 VLM 的简短上下文（节目名、角色名），与 `background_research.json` 合并 |
+| `--scene-threshold` | `0.1` | 场景检测阈值 |
+| `--style` | `纪录片` | 写进创作简报的解说风格 |
+| `--edit-mode full\|cut` | 不设 | 写进简报的 recap 模式；`cut` 时按剪后时长估算旁白预算，已有 `edited_source.mp4` 时句末锚点改用剪后时间 |
+| `--target-duration` | 不设 | 写进简报的 cut 目标时长；尚无 `clip_plan_validated.json` 时用它估算旁白预算 |
+| `--skip-asr` | 关 | 不转写对白，把 `asr_result.json` 写成 `[]`（已有转写会被覆盖），ASR 证据标为显式跳过 |
+| `--mimo-video-overview` | 关 | 按场景块运行 MiMo 视频概览，并作为逐场景主描述 |
+| `--force` | 关 | 忽略缓存，全部重算 |
+| `--brief-only` | 关 | 只用现有产物重建 `agent_narration_brief.md`，不抽帧、不调 API |
+| `--edited-storyboard-only` | 关 | 只按 `clip_plan_validated.json` 写剪后时间线 `storyboard/edited_storyboard.*`，并在已有的 `agent_narration_brief.md` 顶部加 storyboard 指引；多源计划（带 `sources`）从各来源 `source_work_dir` 的 `frames/` 按其 `frames_manifest.json` 的 fps 取帧，tile 标 `S1`/`S2`…；不抽帧、不调 API，故事板生成失败只记日志。与 `--brief-only` 互斥 |
+| `--consolidate` / `--no-consolidate` | 开 | 生成全局故事索引 `understanding_index.*` |
+| `--consolidate-asr` | 关 | 另外清洗 ASR 文本，写 `asr_clean.json` |
+
 ## 5. 输出契约
 
+默认运行写出下表产物；各阶段产物旁的 `*.meta.json` 是缓存 provenance sidecar。
+
 | 文件 | 内容 |
 |------|------|
+| `frames/frame_*.jpg`、`frames_manifest.json` | 按 fps 抽出的帧及其清单 |
 | `scenes.json` | 场景切点、起止时间与时长 |
+| `audio.wav` | 16 kHz 单声道音频，供 ASR、静音检测与句末锚点使用 |
 | `asr_result.json` | `[{start, end, text}]` 时间戳对白 |
 | `asr_timing_evidence.json` | ASR 可用性状态、粗窗口精度、glossary 前后文本，以及它所描述的源视频/音频/结果文件（路径存在性 + size/mtime） |
-| `vlm_analysis.json` | 逐场景描述、深层分析与 `frame_facts` |
 | `silence_periods.json` | `[{start, end, duration, has_speech}]` 安静窗口 |
+| `speech_boundary_anchors.json` | ASR 句末标点对齐到短停顿的句末锚点；缺音频或 ASR 时 `status: unavailable` |
+| `vlm_analysis.json` | 逐场景描述、深层分析与 `frame_facts` |
+| `mimo_video_overview.status.json` | 视频概览状态（未启用时为 `disabled`）；启用成功另写 `mimo_video_overview.json` |
+| `understanding_index.json`、`understanding_index.md` | 全局故事索引（`--no-consolidate` 时不写） |
+| `consolidation.status.json` | 故事索引与 ASR 清洗的运行状态 |
+| `storyboard/source_storyboard.{json,jpg}` | 原片时间线联系表（超页时续写 `_001.jpg` 等）；已有 `clip_plan_validated.json` 时另写 `edited_storyboard.*`；`STORYBOARD=0` 关闭 |
 | `timeline_fusion.json` | VLM、ASR 与静音信息的统一时间线 |
 | `asr_writing_chunks.json` | 按句界和场景切分的 ASR 写作块 |
 | `agent_narration_brief.md` | Agent 首先阅读的创作简报 |

package/lib/video-recap/skills/video-understanding/references/data-schema.md

@@ -79,11 +79,9 @@ ASR 的独立证据 sidecar，不改变 `asr_result.json` 的既有数组结构
 ```
 
 `status` 可为 `AVAILABLE_COARSE`、`EXPLICITLY_SKIPPED`、`UNAVAILABLE_NO_KEY`、
-`UNAVAILABLE_NO_DURATION`、`FAILED_AUDIO_EXTRACTION`、`FAILED_PROVIDER`、`EMPTY_UNKNOWN`
-或 `LEGACY_UNVERIFIED`。`LEGACY_UNVERIFIED` 标记没有旧 sidecar 的兼容缓存，可离线复用但
-`observed_text`/`glossary_modified` 为 `null`，且始终保持 legacy 身份；非 legacy sidecar 记录
-当时参与修正的人名/别名列表（`glossary.names`），人名表变化或所描述的文件被重写（size/mtime 不再
-一致）都会使 ASR 缓存失效。
+`UNAVAILABLE_NO_DURATION`、`FAILED_AUDIO_EXTRACTION`、`FAILED_PROVIDER` 或 `EMPTY_UNKNOWN`。
+sidecar 记录当时参与修正的人名/别名列表（`glossary.names`），人名表变化、所描述的文件被重写
+（size/mtime 不再一致）或 sidecar 缺失，都会使 ASR 缓存失效并重跑 ASR。
 `UNAVAILABLE_NO_DURATION` 与 `EMPTY_UNKNOWN` 是可重试的不可用结果，不作为缓存命中；写作
 brief 会校验 sidecar 并打印当前状态，缺失或与当前文件不一致时显示 `MISSING_OR_STALE`。
 
@@ -143,22 +141,7 @@ brief 会校验 sidecar 并打印当前状态，缺失或与当前文件不一
 ]
 ```
 
-## deslop_qc_requirements.json（工具/brief 生成的运行契约）
-
-`deslop_qc_requirements.json` 是 tool/brief generated run contract：工具或 brief 生成本次运行的 QC 要求，供 `deslop_qc` 读取，不由 Agent 手写。字段为 `schema_version` 与 `style_card_required`。
-
-`style_card_required` 默认 `false`（advisory）：缺少 `style_card.json` 只是 warning，不阻断出片。将来的 opt-in 运行可把它设为 `true`，让 `style_card.json` 成为硬性要求——`deslop_qc` 只读这个字段判断缺少 `style_card.json` 是否是 blocker，不扫描 `agent_narration_brief.md` 的 prompt wording 来推断。如果 requirements 文件缺失或损坏，按 legacy/migration advisory 处理，不作为 hard failure。
-
-该契约不改变 `--style`：`--style` 仍是 freeform verbatim guidance，不增加固定风格档位。它也不改变 `deslop_qc` 边界：仍然是 report-only，不是 AIGC detector，不自动改写。
-
-最小示例：
-
-```json
-{
-  "schema_version": 1,
-  "style_card_required": false
-}
-```
+cut 第二轮（已有 `edited_source.mp4`）时本文件与 `asr_writing_chunks.json` 都在 OUTPUT 时间轴上：被拆到多个片段的场景 `scene_id` 写作 `"3.1"`（0 起的原场景号加片段序号）；VLM 文字里落在场景原片区间内的时间改写成输出时间，落在被剪掉部分的写 `[cut-away moment]`；只被剪进一部分的 ASR 窗口文字换成 `[partial ASR window: only part of it is in the cut, text withheld]`。`scene_id` 一律 0 起，brief 里给人看的场景号从 1 数。
 
 ## background_research.json
 
@@ -190,4 +173,4 @@ brief 会校验 sidecar 并打印当前状态，缺失或与当前文件不一
 
 ## 其他产物
 
-`narration.json`、`narration_lint.json`、`style_card.json`、`packaging_plan.json`、`deslop_qc.json`、`clip_plan.json`、`clip_plan_validated.json` 由后续的写稿与剪辑阶段读写，本技能既不生成也不校验它们；其格式以本技能生成的 `agent_narration_brief.md` 和编排器的中间产物契约为准。
+`narration.json`、`narration_lint.json`、`style_card.json`、`packaging_plan.json`、`clip_plan.json`、`clip_plan_validated.json` 由后续的写稿与剪辑阶段读写，本技能既不生成也不校验它们；其格式以本技能生成的 `agent_narration_brief.md` 和编排器的中间产物契约为准。

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

@@ -1,10 +1,30 @@
-"""Normalize, split, budget, and de-duplicate narration text."""
+"""Split, chunk, and budget text for the agent narration brief."""
 
-import copy
 import re
 
-from lib import CONFIG, log
-from deslop_qc import _sentence_pieces, _text_units
+from lib import CONFIG
+
+
+def _sentence_pieces(text: str) -> list[str]:
+    """Split text into sentence-like pieces while keeping terminal punctuation."""
+    text = re.sub(r"\s+", " ", text).strip()
+    if not text:
+        return []
+    parts = re.split(r"([。！？!?；;.])", text)
+    out: list[str] = []
+    for idx in range(0, len(parts), 2):
+        body = parts[idx].strip()
+        punct = parts[idx + 1] if idx + 1 < len(parts) else ""
+        if body or punct:
+            out.append((body + punct).strip())
+    return out or [text]
+
+
+def _text_units(text: str) -> int:
+    """Length unit for prose: CJK characters, otherwise words."""
+    if re.search(r"[\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff]", text):
+        return len(re.sub(r"\s+", "", text))
+    return len(re.findall(r"\b\w+\b", text))
 
 
 def _format_frame_facts(scene):
@@ -16,17 +36,6 @@ def _format_frame_facts(scene):
     return "\n  帧动作:\n" + "\n".join(lines)
 
 
-def _text_char_count(text):
-    """计算文本的有效字数（去除标点和空白，这些不占 TTS 朗读时间）。"""
-    return len(
-        re.sub(
-            r'[，。！？、；：…“”‘’《》〈〉\s"\'「」『』（）()【】\[\]—～·,.!?;:\\-]',
-            "",
-            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()
@@ -177,66 +186,6 @@ def _chunk_asr_for_writing(segments, scenes_analysis, min_chars=None, max_chars=
     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 _scene_available_seconds(start, end):
     return max(0.0, end - start - CONFIG["narration_tail_pad_seconds"])
 
@@ -251,51 +200,5 @@ 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)
-
-
 def _overlap_seconds(start, end, other_start, other_end):
     return max(0.0, min(end, other_end) - max(start, other_start))

package/lib/video-recap/skills/video-understanding/scripts/asr.py

@@ -6,7 +6,7 @@ import time
 from pathlib import Path
 
 from lib import CONFIG
-from lib import log, run_cmd, get_video_duration, mimo_asr_api_call
+from lib import log, run_cmd, get_video_duration, mimo_asr_api_call, is_moderation_refusal
 from detect import _audio_meta_path, _write_audio_meta
 from asr_timing_evidence import (
     EVIDENCE_FILENAME,
@@ -202,13 +202,13 @@ def _run_asr(wav_path):
 
     音频以 base64 data-URI 放进 OpenAI 风格的 chat/completions 消息里，转写文本回到
     choices[0].message.content。API/响应结构失败会抛错，避免把瞬时失败缓存成空转写；
-    只有无音频、超体积等确定不可发送的片段返回空串。
+    音频文件缺失/不可读同样抛错（那是上游 bug，不是静音）；只有空音频、超体积等
+    确定不可发送的片段返回空串。
     """
     try:
         raw = Path(wav_path).read_bytes()
     except OSError as e:
-        log(f"ASR 警告: 无法读取音频 {wav_path}: {e}")
-        return ""
+        raise RuntimeError(f"ASR: 无法读取音频 {wav_path}: {e}") from e
     if not raw:
         return ""
 
@@ -235,11 +235,17 @@ def _run_asr(wav_path):
     except Exception as e:
         raise ASRProviderError(f"MiMo ASR 调用失败: {e}") from e
     try:
-        return _strip_reasoning_residue(str(resp["choices"][0]["message"]["content"] or "")).strip()
+        text = _strip_reasoning_residue(str(resp["choices"][0]["message"]["content"] or "")).strip()
     except (KeyError, IndexError, TypeError):
         raise ASRProviderError(
             f"MiMo ASR 返回结构异常: {json.dumps(resp, ensure_ascii=False)[:200]}"
         )
+    if is_moderation_refusal(text):
+        # The refusal sentence is not dialogue: storing it would put it in the briefs and
+        # make cut/narration safety treat the window as speech. Record no text instead.
+        log(f"ASR 警告: MiMo 内容审核拒绝转写 {Path(wav_path).name}，该段记为无文本")
+        return ""
+    return text
 
 
 def _segment_and_transcribe(audio_wav, segments_dir, total_duration, segment_length=None):