@oh-story/dsh 0.1.8 → 0.1.9

package/lib/video-recap/skills/video-assemble/scripts/artifacts.py

@@ -59,7 +59,7 @@ def _explicit_source_video():
     """Return the cut-mode source video only when the caller opted in explicitly."""
     if not CONFIG.get("source_video_explicit", False):
         return ""
-    return str(CONFIG.get("source_video", "") or "").strip()
+    return CONFIG["source_video"]
 
 
 def _source_video_identity():
@@ -72,17 +72,12 @@ def _source_video_identity():
 
 def _timeline_provenance_status(work_dir):
     data = _load_work_json(work_dir, "timeline.json")
-    if not isinstance(data, dict):
-        return None
-    provenance = data.get("provenance")
-    return provenance if isinstance(provenance, dict) else None
+    return None if data is None else data["provenance"]
 
 
 def _load_work_json(work_dir, name):
+    """Parse a JSON artifact in work_dir; None only when the file does not exist."""
     path = Path(work_dir) / name
     if not path.exists():
         return None
-    try:
-        return json.loads(path.read_text(encoding="utf-8"))
-    except (ValueError, OSError):
-        return None
+    return json.loads(path.read_text(encoding="utf-8"))

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

@@ -34,6 +34,7 @@ def assemble_video(input_video, tts_segments, work_dir, output_path):
 
     video_duration = lib.get_video_duration(input_video)
     canvas = media._probe_canvas(input_video)  # drives subtitle PlayRes/scale so 竖屏 text isn't stretched
+    burn_subtitles = lib.CONFIG["burn_subtitles"]
 
     # 解说整体提速（可选）后，将所有 TTS 片段按时间位置合成到与视频等长的音轨上
     narration_audio._apply_narration_speed(tts_segments, work_dir)
@@ -53,25 +54,23 @@ def assemble_video(input_video, tts_segments, work_dir, output_path):
     srt_path = subtitle_render._generate_srt(tts_segments, work_dir, video_duration)
     lib.log(f"字幕文件: {srt_path}")
     ass_path = None
-    if lib.CONFIG.get("burn_subtitles", False):
+    if burn_subtitles:
         ass_path = subtitle_render._generate_ass(tts_segments, work_dir, video_duration, canvas)
         lib.log(f"压制字幕文件: {ass_path}")
 
     # 可选 BGM：作为一条独立音轨（input [2:a]）混入，旁白处自动压低
-    bgm_path = lib.CONFIG.get("bgm_path", "")
+    bgm_path = lib.CONFIG["bgm_path"]
     has_bgm = bool(bgm_path) and os.path.exists(bgm_path)
     if bgm_path and not has_bgm:
         lib.log(f"  ⚠️ BGM 文件不存在，跳过: {bgm_path}")
     elif has_bgm:
-        lib.log(f"BGM 铺底: {bgm_path} (音量 {lib.CONFIG.get('bgm_volume', 0.18)}，旁白时 {lib.CONFIG.get('bgm_ducking_volume', 0.10)})")
+        lib.log(f"BGM 铺底: {bgm_path} (音量 {lib.CONFIG['bgm_volume']}，旁白时 {lib.CONFIG['bgm_ducking_volume']})")
 
     # 多轨时间线模型（timeline.json）：canonical 渲染仍是 ffmpeg，此模型供检视/可选导出
-    timeline_emit._emit_timeline(input_video, tts_segments, work_dir, video_duration, has_bgm)
+    timeline_emit._emit_timeline(input_video, tts_segments, work_dir, video_duration, canvas, has_bgm)
 
     overlay_filters, overlay_qc = visual_render._visual_overlay_filters(work_dir, canvas, video_duration)
-    mask_filter = visual_render._source_subtitle_mask_filter(
-        canvas, work_dir, tts_segments, video_duration=video_duration
-    )
+    mask_filter = visual_render._source_subtitle_mask_filter(canvas, work_dir, tts_segments, video_duration)
     visual_qc = visual_render._build_visual_qc(
         tts_segments,
         work_dir,
@@ -83,8 +82,8 @@ def assemble_video(input_video, tts_segments, work_dir, output_path):
     visual_render._write_visual_qc(work_dir, visual_qc)
     assembly_qc_path = Path(work_dir) / constants.ASSEMBLY_QC
     assembly_qc_path.unlink(missing_ok=True)
-    if visual_qc.get("blocking"):
-        codes = ", ".join(visual_qc.get("blocking_codes", []))
+    if visual_qc["blocking"]:
+        codes = ", ".join(visual_qc["blocking_codes"])
         raise RuntimeError(f"视觉 QC 失败: {codes}；详见 {Path(work_dir) / constants.VISUAL_QC}")
 
     # 混合原始音频 + 解说音频（+ 可选 BGM）
@@ -112,9 +111,7 @@ def assemble_video(input_video, tts_segments, work_dir, output_path):
     # duration=first + -t trim it back to the video length).
     bgm_input = ["-stream_loop", "-1", "-i", str(bgm_path)] if has_bgm else []
 
-    # 对于超长 volume 表达式（多段解说），使用 -filter_complex_script 避免命令行溢出
     # 末端整体响度归一：ducking 只管相对平衡，这一步统一成片绝对响度
-    aout_label = "[aout]"
     loudnorm_measurement = audio_mix._run_loudnorm_first_pass(
         input_video,
         narration_wav,
@@ -124,54 +121,42 @@ def assemble_video(input_video, tts_segments, work_dir, output_path):
         work_dir,
     )
     final_ln = audio_mix.final_loudnorm_filter(loudnorm_measurement)
-    if final_ln:
-        filter_complex += f";[aout]{final_ln}[aoutln]"
-        aout_label = "[aoutln]"
-        lib.log(f"成片响度归一: {final_ln}")
+    filter_complex += f";[aout]{final_ln}[aoutln]"
+    lib.log(f"成片响度归一: {final_ln}")
 
-    filter_complex_bytes = filter_complex.encode('utf-8')
-    if len(filter_complex_bytes) > constants.FILTER_SCRIPT_THRESHOLD_BYTES:
+    # 对于超长 volume 表达式（多段解说），使用 -filter_complex_script 避免命令行溢出
+    fc_script = None
+    if len(filter_complex.encode("utf-8")) > constants.FILTER_SCRIPT_THRESHOLD_BYTES:
         fc_script = Path(work_dir) / ".filter_complex.txt"
         fc_script.write_text(filter_complex, encoding="utf-8")
-        lib.log(f"使用 filter_complex_script (表达式长度 {len(filter_complex_bytes)} bytes)")
-        cmd = [
-            "ffmpeg", "-y",
-            "-i", str(input_video),
-            "-i", str(narration_wav),
-            *original_audio_input,
-            *bgm_input,
-            "-filter_complex_script", str(fc_script),
-            # 0:v:0 (not 0:v): sources with attached cover art carry a second video stream.
-            # -vf only ever applies to the first one, so mapping all of them makes ffmpeg
-            # abort with "Could not write header (incorrect codec parameters ?)" and leave
-            # an unreadable file — after the whole pipeline has already run.
-            "-map", "0:v:0", "-map", aout_label,
-        ]
+        lib.log(f"使用 filter_complex_script (表达式长度 {len(filter_complex.encode('utf-8'))} bytes)")
+        filter_args = ["-filter_complex_script", str(fc_script)]
     else:
-        cmd = [
-            "ffmpeg", "-y",
-            "-i", str(input_video),
-            "-i", str(narration_wav),
-            *original_audio_input,
-            *bgm_input,
-            "-filter_complex", filter_complex,
-            # 0:v:0 (not 0:v): sources with attached cover art carry a second video stream.
-            # -vf only ever applies to the first one, so mapping all of them makes ffmpeg
-            # abort with "Could not write header (incorrect codec parameters ?)" and leave
-            # an unreadable file — after the whole pipeline has already run.
-            "-map", "0:v:0", "-map", aout_label,
-        ]
+        filter_args = ["-filter_complex", filter_complex]
+    cmd = [
+        "ffmpeg", "-y",
+        "-i", str(input_video),
+        "-i", str(narration_wav),
+        *original_audio_input,
+        *bgm_input,
+        *filter_args,
+        # 0:v:0 (not 0:v): sources with attached cover art carry a second video stream.
+        # -vf only ever applies to the first one, so mapping all of them makes ffmpeg
+        # abort with "Could not write header (incorrect codec parameters ?)" and leave
+        # an unreadable file — after the whole pipeline has already run.
+        "-map", "0:v:0", "-map", "[aoutln]",
+    ]
 
     # Video filter chain: mask source subtitles first (drawbox), then burn our subtitles
     # on top. Either one forces a re-encode; with neither, the video stream is copied.
-    crf = str(lib.CONFIG.get("output_crf", 18))  # env_int already clamps to >=0; keep 0 (lossless) intact
-    preset = str(lib.CONFIG.get("output_preset", "veryfast") or "veryfast")
-    max_h = int(lib.CONFIG.get("output_max_height", 0) or 0)
+    crf = str(lib.CONFIG["output_crf"])  # env_int already clamps to >=0; keep 0 (lossless) intact
+    preset = lib.CONFIG["output_preset"]
+    max_h = lib.CONFIG["output_max_height"]
     vf_chain = []
     if mask_filter:
         vf_chain.append(mask_filter)
     vf_chain.extend(overlay_filters)
-    if lib.CONFIG.get("burn_subtitles", False):
+    if burn_subtitles:
         vf_chain.append(visual_render._subtitle_burn_filter(ass_path))
     # Downscale LAST so the mask + burned subtitles render at native resolution and are then
     # scaled down with the frame (crisp). The helper forces both dimensions even so an odd
@@ -183,6 +168,7 @@ def assemble_video(input_video, tts_segments, work_dir, output_path):
     # needs EVEN width AND height, so normalize odd dims (4:2:2/4:4:4 permit them) before the
     # encode — otherwise libx264 aborts to a 0-byte file. The downscale helper already evens out.
     even = "scale=trunc(iw/2)*2:trunc(ih/2)*2"
+    reencode = bool(vf_chain) or lib.CONFIG["force_video_reencode"]
     notes = []
     video_filter_script = None
     if vf_chain:
@@ -202,10 +188,10 @@ def assemble_video(input_video, tts_segments, work_dir, output_path):
         cmd += ["-c:v", "libx264", "-preset", preset, "-crf", crf, "-pix_fmt", "yuv420p"]
         notes = ((["遮挡原字幕"] if mask_filter else [])
                  + ([f"视觉叠加×{len(overlay_filters)}"] if overlay_filters else [])
-                 + (["压制解说字幕"] if lib.CONFIG.get("burn_subtitles", False) else [])
+                 + (["压制解说字幕"] if burn_subtitles else [])
                  + ([f"缩放≤{max_h}p"] if max_h > 0 else []))
         lib.log(f"视频重编码: {' + '.join(notes)} (crf={crf}, preset={preset})")
-    elif lib.CONFIG.get("force_video_reencode", False):
+    elif reencode:
         notes = ["force_video_reencode"]
         cmd += ["-vf", even, "-c:v", "libx264", "-preset", preset, "-crf", crf, "-pix_fmt", "yuv420p"]
     else:
@@ -220,8 +206,8 @@ def assemble_video(input_video, tts_segments, work_dir, output_path):
         if result.returncode != 0:
             raise RuntimeError(f"视频组装失败: {result.stderr}")
     finally:
-        # 清理临时 filter_complex 脚本（无论 ffmpeg 是否成功）
-        if len(filter_complex_bytes) > constants.FILTER_SCRIPT_THRESHOLD_BYTES:
+        # 清理临时 filter 脚本（无论 ffmpeg 是否成功）
+        if fc_script is not None:
             fc_script.unlink(missing_ok=True)
         if video_filter_script is not None:
             video_filter_script.unlink(missing_ok=True)
@@ -237,10 +223,10 @@ def assemble_video(input_video, tts_segments, work_dir, output_path):
             loudnorm_measurement=loudnorm_measurement,
             visual_qc=visual_qc,
             render_delivery={
-                "video_encode_passes": 1 if (vf_chain or lib.CONFIG.get("force_video_reencode", False)) else 0,
-                "reencode_reason": notes if (vf_chain or lib.CONFIG.get("force_video_reencode", False)) else [],
+                "video_encode_passes": 1 if reencode else 0,
+                "reencode_reason": notes,
                 "audio_sample_rate": 48000,
-                "final_compat_notes": ["yuv420p"] if (vf_chain or lib.CONFIG.get("force_video_reencode", False)) else ["video_copy", "aac_48000", "faststart"],
+                "final_compat_notes": ["yuv420p"] if reencode else ["video_copy", "aac_48000", "faststart"],
             },
         ),
     )
@@ -250,7 +236,6 @@ def assemble_video(input_video, tts_segments, work_dir, output_path):
 def main():
     import argparse
     import shutil
-    from pathlib import Path
     ap = argparse.ArgumentParser(
         description="video-assemble: mux narration audio over the video, duck the original, render subtitles.")
     ap.add_argument("video", help="source video (edited_source.mp4 in cut mode, else the original)")
@@ -294,6 +279,8 @@ def main():
         if "SUBTITLE_MASK_OPACITY" not in os.environ:
             lib.CONFIG["subtitle_mask_opacity"] = 1.0
     if args.source_video:
+        if not os.path.exists(args.source_video):
+            ap.error(f"--source-video does not exist: {args.source_video}")
         lib.CONFIG["source_video"] = args.source_video
         lib.CONFIG["source_video_explicit"] = True
     else:
@@ -313,9 +300,9 @@ def main():
     tts_segments = json.loads(tts_meta.read_text(encoding="utf-8"))["segments"]
     output_path = work_dir / "output.mp4"
     assemble_video(args.video, tts_segments, work_dir, output_path)
-    assembly_qc = artifacts._load_work_json(work_dir, constants.ASSEMBLY_QC) or {}
-    if assembly_qc.get("blocking"):
-        codes = ", ".join(assembly_qc.get("blocking_codes") or ["unknown"])
+    assembly_qc = artifacts._load_work_json(work_dir, constants.ASSEMBLY_QC)
+    if assembly_qc["blocking"]:
+        codes = ", ".join(assembly_qc["blocking_codes"])
         raise SystemExit(f"组装 QC 阻断交付: {codes}；详见 {work_dir / constants.ASSEMBLY_QC}")
     stem = args.recap_stem or Path(args.video).stem
     base = Path(args.output_dir) if args.output_dir else work_dir.parent
@@ -333,7 +320,7 @@ def main():
 
     # OPTIONAL, decoupled: export a 剪映 draft from the timeline (lazy import; never
     # required by the core render path).
-    if lib.CONFIG.get("export_jianying"):
+    if lib.CONFIG["export_jianying"]:
         from jianying_optional import _maybe_export_jianying
         _maybe_export_jianying(work_dir, args.jianying_out, stem)
 

package/lib/video-recap/skills/video-assemble/scripts/assembly_contract.py

@@ -10,7 +10,6 @@ from assemble_constants import (
     ASSEMBLY_MANIFEST,
     ASSEMBLY_QC,
     SEGMENT_AUDIO_SCHEMA_VERSION,
-    VISUAL_QC,
 )
 from audio_mix import _loudness_mode
 from artifacts import (
@@ -19,6 +18,12 @@ from artifacts import (
     _timeline_provenance_status,
 )
 
+_AUDIO_QC_CODES = frozenset({
+    "missing_narration", "skipped_segments", "no_safe_fit", "effective_tempo_exceeded",
+    "empty_narration", "truncated_speech", "unsafe_source_handoff", "timeline_audio_mismatch",
+})
+
+
 def _assembly_manifest_payload(input_video, tts_segments, work_dir, output_path,
                                tts_meta_path=None, final_output=None, *, settings_fingerprint):
     """Slim render record. The orchestrator reads `final_output` to report the result;
@@ -28,34 +33,34 @@ def _assembly_manifest_payload(input_video, tts_segments, work_dir, output_path,
     output_path = Path(output_path)
     source_video, source_video_fingerprint = _source_video_identity()
     qc_path = Path(work_dir) / ASSEMBLY_QC
-    qc = _load_work_json(work_dir, ASSEMBLY_QC) if qc_path.exists() else None
+    qc = _load_work_json(work_dir, ASSEMBLY_QC) or {}
     payload = {
         "schema_version": 2,
         "input_video": str(input_video.resolve()),
         "source_video": source_video,
         "source_video_fingerprint": source_video_fingerprint,
         "tts_meta": str(Path(tts_meta_path).resolve()) if tts_meta_path else None,
-        "tts_segments": len(tts_segments or []),
+        "tts_segments": len(tts_segments),
         "assembly_settings": settings_fingerprint(work_dir),
         "output_path": str(output_path.resolve()),
         "segment_audio_schema_version": SEGMENT_AUDIO_SCHEMA_VERSION,
-        "qc_path": str(qc_path.resolve()) if qc_path.exists() else None,
-        "qc_verdict": qc.get("verdict") if isinstance(qc, dict) else None,
-        "qc_blocking_codes": qc.get("blocking_codes", []) if isinstance(qc, dict) else [],
+        "qc_path": str(qc_path.resolve()) if qc else None,
+        "qc_verdict": qc.get("verdict"),
+        "qc_blocking_codes": qc.get("blocking_codes", []),
         # The settings fingerprint records the configured/fallback loudness policy; these QC
         # fields record what the just-finished render actually used after the loudnorm probe.
-        "qc_loudness_mode": qc.get("loudness_mode") if isinstance(qc, dict) else None,
-        "qc_loudnorm_measurement": qc.get("loudnorm_measurement") if isinstance(qc, dict) else None,
+        "qc_loudness_mode": qc.get("loudness_mode"),
+        "qc_loudnorm_measurement": qc.get("loudnorm_measurement"),
         "audio_segments": [
             {
-                "index": seg.get("index"),
+                "index": seg["index"],
                 "segment_audio_schema_version": seg.get("segment_audio_schema_version", SEGMENT_AUDIO_SCHEMA_VERSION),
-                "narration": seg.get("narration", ""),
-                "spoken_text": seg.get("spoken_text") or seg.get("narration", ""),
-                "truncated": bool(seg.get("truncated", False)),
+                "narration": seg["narration"],
+                "spoken_text": seg.get("spoken_text", seg["narration"]),
+                "truncated": seg.get("truncated", False),
                 "truncate_reason": seg.get("truncate_reason", "none"),
                 "fit_status": seg.get("fit_status"),
-                "blocking": bool(seg.get("blocking", False)),
+                "blocking": seg.get("blocking", False),
                 "audio_duration": seg.get("audio_duration"),
                 "placed_audio_duration": seg.get("placed_audio_duration"),
                 "placed_audio_path": seg.get("placed_audio_path"),
@@ -72,8 +77,7 @@ def _assembly_manifest_payload(input_video, tts_segments, work_dir, output_path,
                 "rms_dbfs_after": seg.get("rms_dbfs_after"),
                 "peak_after": seg.get("peak_after"),
             }
-            for seg in (tts_segments or [])
-            if isinstance(seg, dict)
+            for seg in tts_segments
         ],
     }
     if final_output is not None:
@@ -91,119 +95,89 @@ def _write_assembly_manifest(work_dir, manifest):
 
 
 def _visual_qc_rollup(visual_qc):
-    if not isinstance(visual_qc, dict):
-        return {
-            "present": False,
-            "verdict": "MISSING",
-            "blocking": True,
-            "blocking_codes": ["missing_visual_qc"],
-            "summary": {},
-        }
-    subtitles = visual_qc.get("subtitles") or visual_qc.get("subtitle") or {}
-    overlays = visual_qc.get("overlays") or visual_qc.get("overlay") or {}
+    subtitles = visual_qc["subtitles"]
+    overlays = visual_qc["overlays"]
     return {
         "present": True,
-        "artifact": visual_qc.get("artifact", VISUAL_QC),
-        "verdict": visual_qc.get("verdict"),
-        "blocking": bool(visual_qc.get("blocking", False)),
-        "blocking_codes": list(visual_qc.get("blocking_codes") or []),
-        "summary": visual_qc.get("summary", {}),
-        "geometry": visual_qc.get("geometry", {}),
+        "artifact": visual_qc["artifact"],
+        "verdict": visual_qc["verdict"],
+        "blocking": visual_qc["blocking"],
+        "blocking_codes": list(visual_qc["blocking_codes"]),
+        "summary": visual_qc["summary"],
+        "geometry": visual_qc["geometry"],
         "subtitles": {
-            "entries": subtitles.get("entries", 0),
-            "multi_line": subtitles.get("multi_line", False),
-            "overflow": subtitles.get("overflow", False),
-            "safe_area": subtitles.get("safe_area", {}),
+            "entries": subtitles["entries"],
+            "multi_line": subtitles["multi_line"],
+            "overflow": subtitles["overflow"],
+            "safe_area": subtitles["safe_area"],
         },
-        "subtitle": subtitles,
-        "mask": visual_qc.get("mask", {}),
+        "mask": visual_qc["mask"],
         "overlays": {
-            "present": overlays.get("present", bool(overlays.get("items"))),
-            "rendered": overlays.get("rendered", len(overlays.get("items", [])) if isinstance(overlays.get("items"), list) else 0),
+            "present": overlays["present"],
+            "rendered": overlays["rendered"],
             "unsupported": overlays.get("unsupported", []),
             "overflow": overlays.get("overflow", []),
         },
-        "overlay": overlays,
     }
 
 
+def _placed_audio_matches_timeline(seg):
+    """True when the persisted per-beat WAV is exactly what the serialized timeline window plays."""
+    placed_path = Path(seg["placed_audio_path"])
+    if not placed_path.exists():
+        return False
+    with wave.open(str(placed_path), "rb") as placed_wav:
+        placed_duration = placed_wav.getnframes() / placed_wav.getframerate()
+        tolerance = 1.0 / placed_wav.getframerate()
+    timeline_start = round(float(seg["actual_place_start"]), 4)
+    timeline_end = math.ceil(float(seg["actual_place_end"]) * 10_000 - 1e-9) / 10_000
+    serialized_span = timeline_end - timeline_start
+    return (
+        abs(placed_duration - seg["placed_audio_duration"]) <= tolerance + 1e-9
+        and serialized_span + 1e-9 >= placed_duration
+    )
+
+
 def _build_assembly_qc(tts_segments, video_duration, *, output_path=None,
                        source_has_audio=None, loudness_mode=None, loudnorm_measurement=None,
-                       visual_qc=None, render_delivery=None, delivery_qc=None):
+                       visual_qc=None, render_delivery=None):
     """Machine-readable assembly release gate.
 
     Visual facts are rolled up from visual_qc.json. Delivery/render facts live here
     (or render/delivery QC in future), never in visual_qc.json.
     """
-    hard_max = float(CONFIG.get("narration_cumulative_tempo_hard_max", 1.40) or 1.40)
-    segments = [s for s in (tts_segments or []) if isinstance(s, dict)]
+    hard_max = CONFIG["narration_cumulative_tempo_hard_max"]
+    segments = tts_segments
     no_safe = [
-        int(s.get("index", i))
-        for i, s in enumerate(segments)
+        s["index"] for s in segments
         if s.get("fit_status") == "no_safe_fit"
         or s.get("truncate_reason") in {"no_safe_boundary", "no_room"}
-        or bool(s.get("blocking", False))
-    ]
-    skipped = [
-        int(s.get("index", i))
-        for i, s in enumerate(segments)
-        if s.get("fit_status") == "skipped"
-    ]
-    fit_failed = [
-        int(s.get("index", i))
-        for i, s in enumerate(segments)
-        if s.get("fit_status") == "speed_adjust_failed"
+        or s.get("blocking", False)
     ]
+    skipped = [s["index"] for s in segments if s.get("fit_status") == "skipped"]
     tempo_exceeded = []
     truncated = []
     handoff_failed = []
     timeline_audio_failed = []
     max_effective = 0.0
-    for i, s in enumerate(segments):
-        try:
-            eff = float(s.get("effective_tempo", 0.0) or 0.0)
-        except (TypeError, ValueError):
-            eff = 0.0
+    for s in segments:
+        eff = float(s["effective_tempo"])
         max_effective = max(max_effective, eff)
         if eff > hard_max + 1e-6:
-            tempo_exceeded.append(int(s.get("index", i)))
-        if bool(s.get("truncated", False)) or s.get("truncate_reason") == "tail_trim_tolerance":
-            truncated.append(int(s.get("index", i)))
-        if bool(s.get("source_handoff_blocking", False)):
-            handoff_failed.append(int(s.get("index", i)))
-        if s.get("actual_place_start") is not None and float(s.get("placed_audio_duration", 0.0) or 0.0) > 0:
-            placed_path = s.get("placed_audio_path")
-            valid_placed_file = False
-            if placed_path and Path(placed_path).exists():
-                try:
-                    with wave.open(str(placed_path), "rb") as placed_wav:
-                        placed_duration = placed_wav.getnframes() / placed_wav.getframerate()
-                        tolerance = 1.0 / placed_wav.getframerate()
-                    timeline_start = round(float(s.get("actual_place_start")), 4)
-                    timeline_end = math.ceil(
-                        float(s.get("actual_place_end")) * 10_000 - 1e-9
-                    ) / 10_000
-                    serialized_span = timeline_end - timeline_start
-                    valid_placed_file = abs(
-                        placed_duration - float(s.get("placed_audio_duration") or 0.0)
-                    ) <= tolerance + 1e-9 and serialized_span + 1e-9 >= placed_duration
-                except (OSError, wave.Error, ZeroDivisionError, TypeError, ValueError):
-                    valid_placed_file = False
-            if not valid_placed_file:
-                timeline_audio_failed.append(int(s.get("index", i)))
+            tempo_exceeded.append(s["index"])
+        if s.get("truncated", False) or s.get("truncate_reason") == "tail_trim_tolerance":
+            truncated.append(s["index"])
+        if s.get("source_handoff_blocking", False):
+            handoff_failed.append(s["index"])
+        if s["placed_audio_duration"] > 0 and not _placed_audio_matches_timeline(s):
+            timeline_audio_failed.append(s["index"])
 
-    placed = [
-        float(s.get("placed_audio_duration", 0.0) or 0.0)
-        for s in segments
-        if s.get("placed_audio_duration") is not None
-    ]
+    placed = [s["placed_audio_duration"] for s in segments]
     blocking_codes = []
     if not segments:
         blocking_codes.append("missing_narration")
     if skipped:
         blocking_codes.append("skipped_segments")
-    if fit_failed:
-        blocking_codes.append("fit_failed")
     if no_safe:
         blocking_codes.append("no_safe_fit")
     if tempo_exceeded:
@@ -221,7 +195,7 @@ def _build_assembly_qc(tts_segments, video_duration, *, output_path=None,
         if visual_qc is not None
         else {"present": False, "verdict": "NOT_RUN", "blocking": False, "blocking_codes": [], "summary": {}}
     )
-    if visual_rollup.get("blocking"):
+    if visual_rollup["blocking"]:
         blocking_codes.append("visual_qc_failed")
     if source_has_audio is False:
         # Not blocking: assemble can synthesize a silent original track.
@@ -242,43 +216,34 @@ def _build_assembly_qc(tts_segments, video_duration, *, output_path=None,
         if output_path.exists() and output["bytes"] <= 0:
             blocking_codes.append("empty_output")
 
-    render_delivery = render_delivery or delivery_qc or {}
-    qc_payload = {
+    delivery = render_delivery if render_delivery is not None else {}
+    return {
         "schema_version": 1,
         "artifact": ASSEMBLY_QC,
         "verdict": "FAIL" if blocking_codes else "PASS",
         "blocking": bool(blocking_codes),
         "blocking_codes": blocking_codes,
-        "duration": round(float(video_duration or 0.0), 4),
+        "duration": round(float(video_duration), 4),
         "source_audio": source_audio,
         "loudness_mode": loudness_mode or _loudness_mode(loudnorm_measurement),
         "loudnorm_measurement": loudnorm_measurement,
         "release_gate": {
             "verdict": "FAIL" if blocking_codes else "PASS",
-            "visual_qc": visual_rollup.get("verdict"),
+            "visual_qc": visual_rollup["verdict"],
             "delivery_qc": "PASS",
-            "audio_qc": "FAIL" if any(
-                c in blocking_codes
-                for c in (
-                    "missing_narration", "skipped_segments", "fit_failed", "no_safe_fit",
-                    "effective_tempo_exceeded", "empty_narration", "truncated_speech",
-                    "unsafe_source_handoff",
-                    "timeline_audio_mismatch",
-                )
-            ) else "PASS",
+            "audio_qc": "FAIL" if _AUDIO_QC_CODES.intersection(blocking_codes) else "PASS",
         },
         "visual_qc": visual_rollup,
         "delivery_qc": {
-            "video_encode_passes": render_delivery.get("video_encode_passes"),
-            "reencode_reason": render_delivery.get("reencode_reason"),
-            "audio_sample_rate": render_delivery.get("audio_sample_rate"),
-            "final_compat_notes": render_delivery.get("final_compat_notes", []),
+            "video_encode_passes": delivery.get("video_encode_passes"),
+            "reencode_reason": delivery.get("reencode_reason"),
+            "audio_sample_rate": delivery.get("audio_sample_rate"),
+            "final_compat_notes": delivery.get("final_compat_notes", []),
         },
         "summary": {
             "segments": len(segments),
             "placed_segments": sum(1 for x in placed if x > 0.0),
             "skipped_segments": skipped,
-            "fit_failed_segments": fit_failed,
             "no_safe_fit_segments": no_safe,
             "tempo_exceeded_segments": tempo_exceeded,
             "max_effective_tempo": round(max_effective, 4),
@@ -288,9 +253,6 @@ def _build_assembly_qc(tts_segments, video_duration, *, output_path=None,
         },
         "output": output,
     }
-    qc_payload["visual_rollup"] = visual_rollup
-    qc_payload["delivery_rollup"] = qc_payload["delivery_qc"]
-    return qc_payload
 
 
 def _write_assembly_qc(work_dir, qc):