Feature/video artifact verification (#537)

* fix(release): CI wait polls the prod rung; escape the header tooltip apostrophe

get_latest_ci_conclusion defaults to the ladder's head rung, so
wait_for_ci searched slave for a release commit that lives on master
and timed out after 40 minutes with the run already green. The wait
now passes the prod branch explicitly. Also fixes the
react/no-unescaped-entities error that turned master's Panel CI red.

* fix(panel,video): dead dialog triggers behind tooltips; dotted composition ids render

HelpTip nested inside a Dialog/AlertDialog trigger puts the trigger's
click handler on the Tooltip root, which renders no DOM — the agents
Spawn item and the KB Reindex-All / Delete-index confirms were dead.
Tooltips now wrap the triggers. The video renderer accepts interior
single dots in composition ids (release-0.25.0) with '..' still
unrepresentable, and propose_video refuses an unrenderable id at
authoring time.

* fix(dispatch): restart-safe PM review turns

A leaf task in awaiting_pm_review had no periodic pickup: the closure
dispatcher bailed on childless tasks and skipped PR-bearing review
tasks as already-promoted, assuming the submit-time PM session was
still alive — an assumption every restart breaks. Proven live on the
docs-sync leaf after the 0.25.0 redeploy, which also dependency-blocked
its sibling dev task. Childless awaiting_pm_review tasks now flow to
the PM's review turn, and the merge turn respawns its PM when none is
active.

* feat(video): verify the rendered artifact, not the source

The 14s release-0.25.0 cut shipped with only one of four scenes visibly
registering: the dev authored DOM, the smoke asserted DOM, QA read code —
nobody consumed the rendered MP4 before the CEO did. Close that loop, and
the reject loop behind it:

- sidecar frames mode: POST /render with frames=1..32 renders the cut,
  ffprobes the REAL duration, extracts midpoint-sampled keyframe PNGs
  (timestamps in filenames), streams a tar.gz back with X-Video-Duration
- request_render do-verb (developer/QA, request_sandbox's shape): renders
  the caller's ACTUAL composition — dev's own worktree (head_sha/dirty
  provenance), QA a read-only git-archive export of the assembled branch —
  extracts frames to the container-shared .previews/ path, stamps the
  render_preview marker, returns the paths as envelope evidence
- gate: i_am_done on a source=video task refuses without a stamped
  render_preview (Requirement.RENDER_VERIFIED; canonical source string
  moved to foundation as markers.VIDEO_TASK_SOURCE; mirrored in the
  possibilities-matrix fast path so it cannot bypass the check)
- QA claim_review evidence carries video_context (composition id, the
  dev's preview, a re-render instruction) so review checks output
- dev spawn prompt block + a 4th authoring AC order Read-every-frame
  verification before submitting
- reject -> re-author: a CEO reject with a reason opens a fresh authoring
  task carrying the verbatim feedback + a revise-in-place pointer at the
  existing composition (best-effort, never fails the reject) — rejection
  feedback no longer dies on the cancelled draft

E2E: rendered the committed release-0.25.0 composition through the new
frames mode locally — the returned keyframes show exactly the reported
failure (blank frame at 5.8s, only 'Env ladder' by 12.8s), the check the
fleet was missing.

---------

Co-authored-by: Renn F <rennf93@users.noreply.github.com>

tests/unit/services/test_video_renderer_client.py

@@ -152,6 +152,130 @@ async def test_null_renderer_raises_without_network_call(tmp_path: Path) -> None
         )
 
 
+@pytest.mark.asyncio
+async def test_render_frames_posts_frames_field_and_parses_duration(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    source = _make_source(tmp_path)
+    monkeypatch.setattr(cfg, "video_request_timeout_seconds", 5.0)
+    monkeypatch.setattr(cfg, "video_render_timeout_seconds", 30.0)
+    captured: dict[str, bytes] = {}
+
+    expected_duration = 12.5
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        captured["body"] = request.content
+        return httpx.Response(
+            200,
+            content=b"fake-frames-tar-gz",
+            headers={"X-Video-Duration": str(expected_duration)},
+        )
+
+    transport = httpx.MockTransport(handler)
+    http_client = httpx.AsyncClient(transport=transport)
+    renderer = VideoRenderer(base_url="http://fake-video-renderer", client=http_client)
+
+    tar_bytes, duration = await renderer.render_frames(
+        str(source),
+        composition_id="Intro",
+        input_props={"title": "hello"},
+        orientation="vertical",
+        frame_count=8,
+    )
+    await http_client.aclose()
+
+    assert tar_bytes == b"fake-frames-tar-gz"
+    assert duration == expected_duration
+    body = captured["body"]
+    assert isinstance(body, bytes)
+    assert b'name="frames"' in body
+    assert b"8" in body
+
+
+@pytest.mark.asyncio
+async def test_render_frames_missing_duration_header_returns_zero(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    source = _make_source(tmp_path)
+    monkeypatch.setattr(cfg, "video_request_timeout_seconds", 5.0)
+    monkeypatch.setattr(cfg, "video_render_timeout_seconds", 30.0)
+
+    def handler(_request: httpx.Request) -> httpx.Response:
+        return httpx.Response(200, content=b"fake-frames-tar-gz")
+
+    transport = httpx.MockTransport(handler)
+    http_client = httpx.AsyncClient(transport=transport)
+    renderer = VideoRenderer(base_url="http://fake-video-renderer", client=http_client)
+
+    tar_bytes, duration = await renderer.render_frames(
+        str(source),
+        composition_id="Intro",
+        input_props={},
+        orientation="square",
+        frame_count=4,
+    )
+    await http_client.aclose()
+
+    assert tar_bytes == b"fake-frames-tar-gz"
+    assert duration == 0.0
+
+
+@pytest.mark.asyncio
+async def test_render_frames_non_success_response_raises_clear_error(
+    tmp_path: Path,
+) -> None:
+    source = _make_source(tmp_path)
+
+    def handler(_request: httpx.Request) -> httpx.Response:
+        return httpx.Response(400, text="frames out of bounds")
+
+    transport = httpx.MockTransport(handler)
+    http_client = httpx.AsyncClient(transport=transport)
+    renderer = VideoRenderer(base_url="http://fake-video-renderer", client=http_client)
+
+    with pytest.raises(VideoRendererError, match="400"):
+        await renderer.render_frames(
+            str(source),
+            composition_id="Intro",
+            input_props={},
+            orientation="square",
+            frame_count=4,
+        )
+    await http_client.aclose()
+
+
+@pytest.mark.asyncio
+async def test_render_frames_unconfigured_renderer_raises_without_network_call(
+    tmp_path: Path,
+) -> None:
+    source = _make_source(tmp_path)
+    renderer = VideoRenderer(base_url="")
+    with pytest.raises(VideoRendererError, match="not configured"):
+        await renderer.render_frames(
+            str(source),
+            composition_id="Intro",
+            input_props={},
+            orientation="vertical",
+            frame_count=4,
+        )
+
+
+@pytest.mark.asyncio
+async def test_render_frames_null_renderer_raises_without_network_call(
+    tmp_path: Path,
+) -> None:
+    source = _make_source(tmp_path)
+    renderer = NullVideoRenderer()
+    with pytest.raises(VideoRendererError, match="not configured"):
+        await renderer.render_frames(
+            str(source),
+            composition_id="Intro",
+            input_props={},
+            orientation="vertical",
+            frame_count=4,
+        )
+
+
 def test_get_video_renderer_returns_null_when_unset(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None: