ai-agent-book 精选快照（<2MB 代码与文档，来自 github.com/bojieli/ai-agent-book）

chapter5/video-edit/campaign.py

@@ -0,0 +1,792 @@
+"""Real-media, real-Vision, real-Blender acceptance campaign for Experiment 5-6."""
+
+from __future__ import annotations
+
+import argparse
+import ast
+import base64
+import hashlib
+import json
+import math
+import os
+import re
+import shutil
+import subprocess
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from openai import OpenAI
+
+
+ROOT = Path(__file__).resolve().parent
+VALIDATION = ROOT / "validation"
+SOURCE_CACHE = VALIDATION / "source_cache" / "big-buck-bunny-trailer-480p.mov"
+SOURCE_URL = "https://download.blender.org/peach/trailer/trailer_480p.mov"
+SOURCE_SHA256 = "36801b74638c12be9aa587e93cd18edfc9bc51a1c089ab2a19ee42beed9f497d"
+BLENDER = Path("/Applications/Blender.app/Contents/MacOS/Blender")
+GROUND_TRUTH = {"start": 9.08, "end": 11.20}
+TARGET = (
+    "the single continuous shot showing the large white rabbit walking alone in a sunny green "
+    "meadow, after the ONE BIG RABBIT title and before the THREE RODENTS title"
+)
+REQUEST = (
+    "Cut out the shot of the large white rabbit walking alone in the sunny meadow, slow it to "
+    "1.5x duration, and add the subtitle BIG BUNNY along the bottom."
+)
+
+
+def _utc() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _sha(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def _write_json(path: Path, value: Any) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    text = json.dumps(value, ensure_ascii=False, indent=2) + "\n"
+    if re.search(r"\b(?:sk|gh[opusr])-[A-Za-z0-9_-]{12,}\b", text):
+        raise ValueError(f"credential-shaped value in {path}")
+    path.write_text(text, encoding="utf-8")
+
+
+def _probe(path: Path) -> dict[str, Any]:
+    process = subprocess.run(
+        [
+            "ffprobe", "-v", "error", "-show_entries",
+            "format=duration,size,format_name:stream=index,codec_type,codec_name,width,height,r_frame_rate,sample_rate,channels",
+            "-of", "json", str(path),
+        ],
+        check=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+    )
+    return json.loads(process.stdout)
+
+
+def _extract(source: Path, timestamp: float, output: Path) -> None:
+    output.parent.mkdir(parents=True, exist_ok=True)
+    subprocess.run(
+        [
+            "ffmpeg", "-hide_banner", "-loglevel", "error", "-ss", f"{timestamp:.3f}",
+            "-i", str(source), "-frames:v", "1", "-vf", "scale=640:-2", "-y", str(output),
+        ],
+        check=True,
+    )
+    if not output.is_file():
+        raise RuntimeError(f"ffmpeg produced no frame at {timestamp:.3f}s: {source}")
+
+
+def _frame_set(source: Path, timestamps: list[float], directory: Path) -> list[dict[str, Any]]:
+    result = []
+    for timestamp in timestamps:
+        # PNG avoids the local ffmpeg build's strict MJPEG full-range rejection
+        # on the trailer's final credits frame while preserving the exact pixels.
+        path = directory / f"frame-{timestamp:06.2f}.png"
+        _extract(source, timestamp, path)
+        result.append(
+            {
+                "timestamp_s": timestamp,
+                "path": str(path),
+                "sha256": _sha(path),
+                "bytes": path.stat().st_size,
+            }
+        )
+    return result
+
+
+class Backend:
+    def __init__(self, provider: str):
+        if provider == "ark":
+            key = os.environ.get("ARK_API_KEY")
+            self.endpoint = os.environ.get("ARK_BASE_URL") or "https://ark.cn-beijing.volces.com/api/v3"
+            self.model = os.environ.get("ARK_MODEL") or "doubao-seed-1-6-250615"
+        elif provider == "moonshot":
+            key = os.environ.get("MOONSHOT_API_KEY") or os.environ.get("KIMI_API_KEY")
+            self.endpoint = os.environ.get("MOONSHOT_BASE_URL") or "https://api.moonshot.cn/v1"
+            self.model = os.environ.get("KIMI_MODEL") or "kimi-k3"
+        else:
+            key = os.environ.get("OPENAI_API_KEY")
+            self.endpoint = os.environ.get("OPENAI_BASE_URL") or "https://api.openai.com/v1"
+            self.model = os.environ.get("OPENAI_MODEL") or "gpt-5.6-luna"
+        if not key:
+            raise RuntimeError(f"missing credential for {provider}")
+        self.provider = provider
+        self.receipt_checkpoint: Path | None = None
+        self.client = OpenAI(api_key=key, base_url=self.endpoint, timeout=240, max_retries=0)
+
+
+def _json_object(text: str) -> dict[str, Any]:
+    text = text.strip()
+    if text.startswith("```"):
+        text = text.split("\n", 1)[1].rsplit("```", 1)[0]
+    value = json.loads(text)
+    if not isinstance(value, dict):
+        raise ValueError("model response must be an object")
+    return value
+
+
+def _call(
+    backend: Backend,
+    *,
+    purpose: str,
+    messages: list[dict[str, Any]],
+    receipt_messages: list[dict[str, Any]],
+    receipts: list[dict[str, Any]],
+    max_tokens: int,
+) -> dict[str, Any]:
+    request: dict[str, Any] = {
+        "model": backend.model,
+        "messages": messages,
+        "temperature": 0,
+        "max_tokens": max_tokens,
+        "response_format": {"type": "json_object"},
+    }
+    started = time.perf_counter()
+    response = backend.client.chat.completions.create(**request)
+    latency = round(time.perf_counter() - started, 3)
+    content = response.choices[0].message.content or ""
+    usage = response.usage
+    receipts.append(
+        {
+            "purpose": purpose,
+            "provider": backend.provider,
+            "endpoint": backend.endpoint,
+            "request": {
+                "model": backend.model,
+                "messages": receipt_messages,
+                "temperature": 0,
+                "max_tokens": max_tokens,
+                "response_format": {"type": "json_object"},
+            },
+            "response": {
+                "id": response.id,
+                "model": response.model,
+                "finish_reason": response.choices[0].finish_reason,
+                "content": content,
+            },
+            "usage": {
+                "prompt_tokens": getattr(usage, "prompt_tokens", None),
+                "completion_tokens": getattr(usage, "completion_tokens", None),
+                "total_tokens": getattr(usage, "total_tokens", None),
+            },
+            "latency_s": latency,
+        }
+    )
+    if backend.receipt_checkpoint is not None:
+        _write_json(backend.receipt_checkpoint, {"calls": receipts})
+    return _json_object(content)
+
+
+def _vision(
+    backend: Backend,
+    *,
+    purpose: str,
+    prompt: str,
+    frames: list[dict[str, Any]],
+    receipts: list[dict[str, Any]],
+) -> dict[str, Any]:
+    content: list[dict[str, Any]] = [{"type": "text", "text": prompt}]
+    summarized: list[dict[str, Any]] = [{"type": "text", "text": prompt}]
+    for frame in frames:
+        path = Path(frame["path"])
+        content.append({"type": "text", "text": f"timestamp={frame['timestamp_s']:.2f}s"})
+        content.append(
+            {
+                "type": "image_url",
+                "image_url": {
+                    "url": "data:image/png;base64," + base64.b64encode(path.read_bytes()).decode("ascii"),
+                    "detail": "low",
+                },
+            }
+        )
+        summarized.append({"type": "text", "text": f"timestamp={frame['timestamp_s']:.2f}s"})
+        summarized.append(
+            {
+                "type": "image_artifact",
+                "path": frame["path"],
+                "sha256": frame["sha256"],
+                "bytes": frame["bytes"],
+            }
+        )
+    return _call(
+        backend,
+        purpose=purpose,
+        messages=[{"role": "user", "content": content}],
+        receipt_messages=[{"role": "user", "content": summarized}],
+        receipts=receipts,
+        max_tokens=700,
+    )
+
+
+def _bounds(value: dict[str, Any], duration: float) -> tuple[float, float]:
+    start = float(value["start"])
+    end = float(value["end"])
+    if not (0 <= start < end <= duration):
+        raise ValueError(f"invalid model interval [{start}, {end}] for duration {duration}")
+    return start, end
+
+
+def _script_is_safe(code: str, source: Path, output: Path) -> None:
+    tree = ast.parse(code)
+    imports = {
+        alias.name
+        for node in ast.walk(tree)
+        if isinstance(node, (ast.Import, ast.ImportFrom))
+        for alias in node.names
+    }
+    if "bpy" not in imports:
+        raise ValueError("generated script does not import bpy")
+    forbidden_imports = {"subprocess", "socket", "requests", "urllib", "http", "ftplib"}
+    if imports & forbidden_imports:
+        raise ValueError(f"generated script imports forbidden modules: {sorted(imports & forbidden_imports)}")
+    forbidden_calls = {"eval", "exec", "compile", "__import__", "system", "popen", "remove", "unlink", "rmtree"}
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Call):
+            name = ""
+            if isinstance(node.func, ast.Name):
+                name = node.func.id
+            elif isinstance(node.func, ast.Attribute):
+                name = node.func.attr
+            if name.casefold() in forbidden_calls:
+                raise ValueError(f"generated script calls forbidden function: {name}")
+    if str(source.resolve()) not in code or str(output.resolve()) not in code:
+        raise ValueError("generated script does not pin the supplied input and output paths")
+    required_markers = ("new_movie", "frame_offset_start", "new_effect", "TEXT", "SPEED", "render")
+    missing = [marker for marker in required_markers if marker not in code]
+    if missing:
+        raise ValueError(f"generated script omits requested Blender API operations: {missing}")
+
+
+def _render_model_script(
+    backend: Backend,
+    *,
+    label: str,
+    source: Path,
+    output: Path,
+    start: float,
+    end: float,
+    scripts: Path,
+    logs: Path,
+    receipts: list[dict[str, Any]],
+) -> dict[str, Any]:
+    prompt = f"""Generate a complete Blender 4.3 Python script for this video edit.
+
+Input movie: {source.resolve()}
+Output MP4: {output.resolve()}
+Source FPS: 25
+Source size: 853x480; render at 854x480 (one-pixel even-width pad required by H.264)
+Trim interval: [{start:.3f}, {end:.3f}] seconds
+Effects: slow playback so output duration is 1.5 times the trimmed interval; add bottom-centered subtitle BIG BUNNY with a visible semi-transparent dark box.
+
+Requirements:
+- Use bpy and Blender's Video Sequence Editor, including new_movie, new_sound when available, frame_offset_start/frame_final_duration, a SPEED effect, and a TEXT effect.
+- Render exactly 854x480 at 25 fps through Blender to MPEG-4 H.264 with AAC audio.
+- Set the scene frame range to the slowed duration and call bpy.ops.render.render(animation=True).
+- Create only the requested output. Do not invoke ffmpeg, subprocesses, a shell, the network, or read credentials.
+- Use APIs available in Blender 4.3 (scene.sequence_editor_create().sequences).
+- In Blender 4.3, SpeedControlSequence has no use_audio property. Never read or assign use_audio, and do not apply a SPEED effect to the sound strip. A valid movie slow-motion pattern is speed_control='MULTIPLY', speed_factor=1/1.5, and extending the movie/render duration; the sound strip may remain normally trimmed.
+- For the subtitle background, prefer the TEXT strip's use_box=True and box_color=(0,0,0,0.6); do not assume a COLOR strip has text-layout properties.
+
+Use this real-Blender-4.3-validated timing pattern, substituting the supplied paths and interval but preserving the timing relationships exactly:
+```
+FPS = 25
+start_frame = int(round(START_SECONDS * FPS))
+dur_frames = max(1, int(round((END_SECONDS - START_SECONDS) * FPS)))
+render_dur = int(round(dur_frames * 1.5))
+se = scene.sequence_editor_create()
+movie = se.sequences.new_movie(name='clip', filepath=INPUT_PATH, channel=1,
+                               frame_start=1 - start_frame)
+sound = se.sequences.new_sound(name='audio', filepath=INPUT_PATH, channel=2,
+                               frame_start=1 - start_frame)
+for strip in (movie, sound):
+    strip.frame_offset_start = start_frame
+    strip.frame_final_duration = dur_frames
+speed = se.sequences.new_effect(name='slowmo', type='SPEED', channel=3,
+                                frame_start=1, frame_end=1 + dur_frames, seq1=movie)
+speed.use_default_fade = False
+speed.speed_control = 'MULTIPLY'
+speed.speed_factor = 1.0 / 1.5
+movie.frame_final_duration = render_dur
+text = se.sequences.new_effect(name='subtitle', type='TEXT', channel=4,
+                               frame_start=1, frame_end=1 + render_dur)
+text.text = 'BIG BUNNY'; text.location = (0.5, 0.12)
+text.align_x = 'CENTER'; text.align_y = 'BOTTOM'
+text.use_box = True; text.box_color = (0.0, 0.0, 0.0, 0.6)
+scene.frame_start = 1; scene.frame_end = render_dur
+```
+This pattern was executed against Blender 4.3.2 and visibly retained the requested source frames through the whole slowed output. Do not replace its negative source-strip frame_start with frame_start=1: frame_offset_start would then move the visible strip later and render black frames.
+
+Return one JSON object only: {{"code":"complete executable Python source"}}.
+"""
+    feedback = ""
+    attempts: list[dict[str, Any]] = []
+    for attempt in range(1, 7):
+        payload = _call(
+            backend,
+            purpose=f"blender_script_{label}_attempt_{attempt}",
+            messages=[
+                {"role": "system", "content": "You are a Blender VSE engineer. Return one JSON object only."},
+                {"role": "user", "content": prompt + (f"\nPrior executable feedback:\n{feedback}" if feedback else "")},
+            ],
+            receipt_messages=[
+                {"role": "system", "content": "You are a Blender VSE engineer. Return one JSON object only."},
+                {"role": "user", "content": prompt + (f"\nPrior executable feedback:\n{feedback}" if feedback else "")},
+            ],
+            receipts=receipts,
+            max_tokens=7000,
+        )
+        code = payload.get("code")
+        script_path = scripts / f"{label}-attempt-{attempt}.py"
+        if not isinstance(code, str):
+            feedback = "Response lacked a string code field."
+            attempts.append({"attempt": attempt, "accepted": False, "error": feedback})
+            continue
+        script_path.write_text(code, encoding="utf-8")
+        try:
+            _script_is_safe(code, source, output)
+        except (SyntaxError, ValueError) as exc:
+            feedback = f"Static safety/API validation failed: {type(exc).__name__}: {exc}"
+            attempts.append({"attempt": attempt, "script": str(script_path), "accepted": False, "error": feedback})
+            continue
+        if output.exists():
+            output.unlink()
+        started = time.perf_counter()
+        process = subprocess.run(
+            [str(BLENDER), "--background", "--python", str(script_path)],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            timeout=300,
+        )
+        latency = round(time.perf_counter() - started, 3)
+        log_path = logs / f"{label}-attempt-{attempt}.log"
+        log_path.write_text(process.stdout, encoding="utf-8")
+        accepted = (
+            process.returncode == 0
+            and "Traceback (most recent call last)" not in process.stdout
+            and output.is_file()
+            and output.stat().st_size > 1000
+        )
+        attempt_record = {
+                "attempt": attempt,
+                "script": str(script_path),
+                "script_sha256": _sha(script_path),
+                "blender_log": str(log_path),
+                "blender_log_sha256": _sha(log_path),
+                "blender_exit_code": process.returncode,
+                "blender_latency_s": latency,
+                "accepted": accepted,
+        }
+        if not accepted and output.is_file():
+            partial_output = logs / f"{label}-attempt-{attempt}.partial.mp4"
+            output.replace(partial_output)
+            attempt_record["partial_output"] = str(partial_output)
+            attempt_record["partial_output_sha256"] = _sha(partial_output)
+        attempts.append(attempt_record)
+        if accepted:
+            return {"attempts": attempts, "accepted_script": str(script_path), "output": str(output)}
+        feedback = (
+            f"Blender exit={process.returncode}; output_exists={output.exists()}. "
+            "Tail of real Blender log:\n" + "\n".join(process.stdout.splitlines()[-30:])
+        )
+    raise RuntimeError(f"model never generated an executable Blender script for {label}: {attempts}")
+
+
+def _review(
+    backend: Backend,
+    *,
+    purpose: str,
+    clip: Path,
+    directory: Path,
+    receipts: list[dict[str, Any]],
+) -> tuple[dict[str, Any], list[dict[str, Any]]]:
+    duration = float(_probe(clip)["format"]["duration"])
+    timestamps = sorted({round(min(0.35, duration / 5), 3), round(duration / 2, 3), round(max(0.0, duration - 0.35), 3)})
+    frames = _frame_set(clip, timestamps, directory)
+    prompt = f"""Independently review these actual rendered keyframes against this edit request:
+{REQUEST}
+
+The target source shot is: {TARGET}.
+Judge the pixels, not filenames or claims. Return JSON exactly with:
+{{"pass":boolean,"target_present":boolean,"irrelevant_content_present":boolean,
+  "subtitle_visible":boolean,"feedback":"specific evidence from the frames"}}.
+Pass only if all frames show the intended large white rabbit meadow shot without title cards or unrelated scenes and the BIG BUNNY subtitle is visibly overlaid near the bottom.
+"""
+    result = _vision(backend, purpose=purpose, prompt=prompt, frames=frames, receipts=receipts)
+    for key in ("pass", "target_present", "irrelevant_content_present", "subtitle_visible"):
+        if not isinstance(result.get(key), bool):
+            raise ValueError(f"review response lacks boolean {key}")
+    return result, frames
+
+
+def _refine_boundaries(
+    backend: Backend,
+    *,
+    source: Path,
+    duration: float,
+    start: float,
+    end: float,
+    reviewer_feedback: str,
+    round_number: int,
+    directory: Path,
+    receipts: list[dict[str, Any]],
+) -> tuple[float, float, dict[str, Any], list[dict[str, Any]]]:
+    """Ask Vision to tighten a rejected edit using dense source-frame evidence.
+
+    Ground-truth annotations are deliberately not supplied here: the next edit
+    must be driven by the independent review and actual source pixels.
+    """
+    lo = max(0.0, start - 1.0)
+    hi = min(duration, end + 1.0)
+    first_tick = math.ceil(lo * 4)
+    last_tick = math.floor(hi * 4)
+    timestamps = [tick / 4 for tick in range(first_tick, last_tick + 1)]
+    frames = _frame_set(source, timestamps, directory)
+    prompt = f"""A rendered video edit was rejected by an independent pixel reviewer.
+Target shot: {TARGET}
+Prior attempted source interval: [{start:.3f}, {end:.3f}] seconds
+Reviewer feedback: {reviewer_feedback}
+
+These are dense 0.25-second frames from the source around both attempted boundaries.
+Using only the timestamped pixels and the reviewer feedback, return the maximal safe
+continuous interval containing the intended rabbit-meadow shot while excluding every
+neighboring title card or unrelated shot. It is better to trim a fraction of a second
+of the target than include even one title-card frame.
+Return JSON exactly as {{"start":seconds,"end":seconds,"reason":"visual boundary evidence"}}.
+"""
+    result = _vision(
+        backend,
+        purpose=f"reviewer_driven_quarter_second_boundary_refinement_{round_number}",
+        prompt=prompt,
+        frames=frames,
+        receipts=receipts,
+    )
+    refined_start, refined_end = _bounds(result, duration)
+    return refined_start, refined_end, result, frames
+
+
+def run(provider: str, run_id: str) -> dict[str, Any]:
+    run_dir = VALIDATION / "runs" / run_id
+    if run_dir.exists():
+        raise FileExistsError(run_dir)
+    run_dir.mkdir(parents=True)
+    if not SOURCE_CACHE.is_file() or _sha(SOURCE_CACHE) != SOURCE_SHA256:
+        raise RuntimeError("pinned source cache missing or hash mismatch")
+    if not BLENDER.is_file():
+        raise RuntimeError(f"real Blender binary not found: {BLENDER}")
+    source = run_dir / "source.mov"
+    shutil.copy2(SOURCE_CACHE, source)
+    source_probe = _probe(source)
+    duration = float(source_probe["format"]["duration"])
+    backend = Backend(provider)
+    receipts: list[dict[str, Any]] = []
+    backend.receipt_checkpoint = run_dir / "provider_receipts.checkpoint.json"
+    frames_dir = run_dir / "frames"
+    scripts_dir = run_dir / "scripts"
+    logs_dir = run_dir / "blender_logs"
+    scripts_dir.mkdir()
+    logs_dir.mkdir()
+
+    source_evidence = {
+        "url": SOURCE_URL,
+        "title": "Big Buck Bunny trailer (Blender Foundation Peach Open Movie Project)",
+        "license": "Creative Commons Attribution 3.0",
+        "license_url": "https://creativecommons.org/licenses/by/3.0/",
+        "sha256": _sha(source),
+        "probe": source_probe,
+        "naturally_occurring_scenes": True,
+        "ground_truth": {
+            **GROUND_TRUTH,
+            "target": TARGET,
+            "method": "Human-labeled target shot bounded by ffmpeg scene-change frames; source inspection found transitions at 9.08 and 11.20 seconds.",
+            "ffmpeg_scene_threshold": 0.35,
+        },
+    }
+    _write_json(run_dir / "source_evidence.json", source_evidence)
+
+    # Container audio extends slightly beyond the last decodable video frame;
+    # stay 1.5 s inside format duration for the final sparse sample.
+    coarse_times = [0.0, 10.0, 20.0, 30.0, round(duration - 1.5, 3)]
+    coarse_frames = _frame_set(source, coarse_times, frames_dir / "coarse")
+    coarse_prompt = f"""These are frames from one contiguous real trailer sampled about every 10 seconds.
+Locate this target: {TARGET}.
+Return JSON {{"start":seconds,"end":seconds,"reason":"visual evidence"}} with a rough continuous interval. Use timestamps and visual content only."""
+    coarse = _vision(
+        backend,
+        purpose="coarse_10_second_visual_localization",
+        prompt=coarse_prompt,
+        frames=coarse_frames,
+        receipts=receipts,
+    )
+    coarse_start, coarse_end = _bounds(coarse, duration)
+    midpoint = (coarse_start + coarse_end) / 2
+    fine_lo = max(0, math.floor(midpoint - 10))
+    fine_hi = min(duration, math.ceil(midpoint + 10))
+    fine_times = [float(value) for value in range(int(fine_lo), int(math.floor(fine_hi)) + 1)]
+    fine_frames = _frame_set(source, fine_times, frames_dir / "fine")
+    fine_prompt = f"""These are one-second samples from the narrowed window [{fine_lo:.1f}, {fine_hi:.1f}] seconds of the same real trailer.
+Precisely locate the boundaries of this one continuous target shot: {TARGET}.
+Return JSON {{"start":seconds,"end":seconds,"reason":"visual boundary evidence"}}. The answer may interpolate between adjacent one-second samples; do not include either neighboring title card."""
+    fine = _vision(
+        backend,
+        purpose="fine_1_second_visual_localization",
+        prompt=fine_prompt,
+        frames=fine_frames,
+        receipts=receipts,
+    )
+    start, end = _bounds(fine, duration)
+    localization = {
+        "request": REQUEST,
+        "target": TARGET,
+        "coarse_interval_s": 10,
+        "coarse_frames": coarse_frames,
+        "coarse_result": coarse,
+        "fine_interval_s": 1,
+        "fine_window": [fine_lo, fine_hi],
+        "fine_frames": fine_frames,
+        "fine_result": fine,
+        "ground_truth": GROUND_TRUTH,
+        "start_error_s": round(abs(start - GROUND_TRUTH["start"]), 3),
+        "end_error_s": round(abs(end - GROUND_TRUTH["end"]), 3),
+    }
+    _write_json(run_dir / "localization.json", localization)
+
+    negative_output = run_dir / "negative_control.mp4"
+    negative_render = _render_model_script(
+        backend,
+        label="negative-control",
+        source=source,
+        output=negative_output,
+        start=0.0,
+        end=3.0,
+        scripts=scripts_dir,
+        logs=logs_dir,
+        receipts=receipts,
+    )
+    negative_review, negative_frames = _review(
+        backend,
+        purpose="review_negative_control_rendered_pixels",
+        clip=negative_output,
+        directory=frames_dir / "negative-review",
+        receipts=receipts,
+    )
+    correction_triggered = negative_review["pass"] is False
+    if not correction_triggered:
+        raise RuntimeError("independent reviewer failed to reject the obvious wrong-shot negative control")
+
+    final_output = run_dir / "final.mp4"
+    final_render = _render_model_script(
+        backend,
+        label="corrected-final",
+        source=source,
+        output=final_output,
+        start=start,
+        end=end,
+        scripts=scripts_dir,
+        logs=logs_dir,
+        receipts=receipts,
+    )
+    final_review, final_frames = _review(
+        backend,
+        purpose="review_corrected_final_rendered_pixels",
+        clip=final_output,
+        directory=frames_dir / "final-review",
+        receipts=receipts,
+    )
+    correction_rounds: list[dict[str, Any]] = [
+        {
+            "round": 0,
+            "kind": "initial_fine_localization",
+            "plan": {"start": start, "end": end, "effects": ["slowmo:1.5", "subtitle:BIG BUNNY"]},
+            "render": final_render,
+            "review": final_review,
+            "frames": final_frames,
+        }
+    ]
+    # A reviewer rejection is actionable evidence, not merely a failed gate.
+    # Densely inspect the real source pixels, ask Vision to tighten the interval,
+    # then generate and execute a fresh Blender script before reviewing again.
+    for refinement_round in range(1, 4):
+        if final_review["pass"]:
+            break
+        prior_start, prior_end = start, end
+        start, end, refinement, refinement_frames = _refine_boundaries(
+            backend,
+            source=source,
+            duration=duration,
+            start=prior_start,
+            end=prior_end,
+            reviewer_feedback=str(final_review.get("feedback") or ""),
+            round_number=refinement_round,
+            directory=frames_dir / f"boundary-refinement-{refinement_round}",
+            receipts=receipts,
+        )
+        final_render = _render_model_script(
+            backend,
+            label=f"corrected-final-refinement-{refinement_round}",
+            source=source,
+            output=final_output,
+            start=start,
+            end=end,
+            scripts=scripts_dir,
+            logs=logs_dir,
+            receipts=receipts,
+        )
+        final_review, final_frames = _review(
+            backend,
+            purpose=f"review_corrected_final_refinement_{refinement_round}_rendered_pixels",
+            clip=final_output,
+            directory=frames_dir / f"final-review-refinement-{refinement_round}",
+            receipts=receipts,
+        )
+        correction_rounds.append(
+            {
+                "round": refinement_round,
+                "kind": "reviewer_driven_quarter_second_refinement",
+                "prior_interval": [prior_start, prior_end],
+                "source_frames": refinement_frames,
+                "refinement": refinement,
+                "plan": {"start": start, "end": end, "effects": ["slowmo:1.5", "subtitle:BIG BUNNY"]},
+                "render": final_render,
+                "review": final_review,
+                "frames": final_frames,
+            }
+        )
+    localization["reviewer_driven_refinements"] = [
+        {
+            "round": item["round"],
+            "prior_interval": item["prior_interval"],
+            "source_frames": item["source_frames"],
+            "result": item["refinement"],
+        }
+        for item in correction_rounds[1:]
+    ]
+    localization["final_interval"] = [start, end]
+    localization["final_start_error_s"] = round(abs(start - GROUND_TRUTH["start"]), 3)
+    localization["final_end_error_s"] = round(abs(end - GROUND_TRUTH["end"]), 3)
+    _write_json(run_dir / "localization.json", localization)
+    final_probe = _probe(final_output)
+    output_duration = float(final_probe["format"]["duration"])
+    expected_duration = (end - start) * 1.5
+    blender_version = subprocess.run(
+        [str(BLENDER), "--version"], check=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True
+    ).stdout
+    (run_dir / "blender_version.txt").write_text(blender_version, encoding="utf-8")
+    _write_json(
+        run_dir / "review.json",
+        {
+            "negative_control": {
+                "plan": {"start": 0.0, "end": 3.0, "effects": ["slowmo:1.5", "subtitle:BIG BUNNY"]},
+                "render": negative_render,
+                "review": negative_review,
+                "frames": negative_frames,
+            },
+            "correction_triggered": correction_triggered,
+            "correction_rounds": correction_rounds,
+            "corrected_final": {
+                "plan": {"start": start, "end": end, "effects": ["slowmo:1.5", "subtitle:BIG BUNNY"]},
+                "render": final_render,
+                "review": final_review,
+                "frames": final_frames,
+                "probe": final_probe,
+                "expected_slowed_duration_s": expected_duration,
+                "observed_duration_s": output_duration,
+            },
+        },
+    )
+    _write_json(run_dir / "provider_receipts.json", {"calls": receipts})
+
+    video_streams = [stream for stream in final_probe["streams"] if stream.get("codec_type") == "video"]
+    gates = {
+        "pinned_real_public_multiscene_source": source_evidence["sha256"] == SOURCE_SHA256,
+        "coarse_real_vision_about_10_seconds": len(coarse_frames) >= 4 and bool(coarse.get("reason")),
+        "fine_real_vision_every_1_second": len(fine_frames) >= 10 and all(
+            abs(b["timestamp_s"] - a["timestamp_s"] - 1.0) < 1e-6 for a, b in zip(fine_frames, fine_frames[1:])
+        ),
+        "start_boundary_error_le_3s": localization["final_start_error_s"] <= 3.0,
+        "end_boundary_error_le_3s": localization["final_end_error_s"] <= 3.0,
+        "model_generated_blender_python": all(
+            Path(item["accepted_script"]).is_file()
+            for item in [negative_render, *[round_["render"] for round_ in correction_rounds]]
+        ),
+        "actual_blender_execution": all(
+            any(attempt.get("accepted") and attempt.get("blender_exit_code") == 0 for attempt in item["attempts"])
+            for item in [negative_render, *[round_["render"] for round_ in correction_rounds]]
+        ),
+        "reviewer_rejected_bad_edit": negative_review["pass"] is False and negative_review["target_present"] is False,
+        "reviewer_triggered_correction": correction_triggered,
+        "reviewer_accepted_corrected_pixels": final_review["pass"] is True and final_review["target_present"] is True,
+        "subtitle_visually_verified": final_review["subtitle_visible"] is True,
+        "slow_motion_duration_verified": abs(output_duration - expected_duration) <= 0.8,
+        "final_format_and_quality": bool(video_streams)
+        and video_streams[0].get("codec_name") == "h264"
+        and int(video_streams[0].get("width") or 0) == 854
+        and int(video_streams[0].get("height") or 0) == 480,
+        "raw_receipts_usage_latency_complete": all(
+            call.get("response")
+            and call.get("latency_s") is not None
+            and call.get("usage", {}).get("prompt_tokens") is not None
+            and call.get("usage", {}).get("completion_tokens") is not None
+            for call in receipts
+        ),
+    }
+    official_complete = all(gates.values())
+    artifacts = {
+        str(path.relative_to(run_dir)): {"sha256": _sha(path), "bytes": path.stat().st_size}
+        for path in sorted(run_dir.rglob("*"))
+        if path.is_file()
+    }
+    manifest = {
+        "schema_version": "1.0",
+        "experiment": "5-6",
+        "run_id": run_id,
+        "generated_at_utc": _utc(),
+        "provider": backend.provider,
+        "model": backend.model,
+        "source_url": SOURCE_URL,
+        "source_sha256": SOURCE_SHA256,
+        "blender_binary": str(BLENDER),
+        "blender_version": blender_version.splitlines()[0],
+        "localization": {
+            "predicted": [start, end],
+            "ground_truth": [GROUND_TRUTH["start"], GROUND_TRUTH["end"]],
+            "errors_s": [localization["final_start_error_s"], localization["final_end_error_s"]],
+            "reviewer_driven_refinement_rounds": len(correction_rounds) - 1,
+        },
+        "final_video": {"path": "final.mp4", "sha256": _sha(final_output), "probe": final_probe},
+        "model_call_count": len(receipts),
+        "gates": gates,
+        "artifacts": artifacts,
+        "official_complete": official_complete,
+    }
+    _write_json(run_dir / "manifest.json", manifest)
+    if not official_complete:
+        raise RuntimeError("Experiment 5-6 acceptance gates failed: " + json.dumps(gates))
+    _write_json(
+        VALIDATION / "latest.json",
+        {
+            "experiment": "5-6",
+            "run_id": run_id,
+            "manifest": str((run_dir / "manifest.json").relative_to(ROOT)),
+            "manifest_sha256": _sha(run_dir / "manifest.json"),
+            "official_complete": True,
+        },
+    )
+    return manifest
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--provider", choices=("ark", "moonshot", "openai"), default="ark")
+    parser.add_argument("--run-id", default=f"exp5-6-real-blender-{datetime.now().strftime('%Y%m%d-%H%M%S')}")
+    args = parser.parse_args()
+    print(json.dumps(run(args.provider, args.run_id), ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()