[e4ed92d6] Video pipeline per-project requests, re-render action, composition preview (#403)

* [7f2c881a] Project-scope video pipeline + re-render + preview proxy (#386) (#396) * [7f2c881a] feat(video): scope on-demand video requests + render loop to project_id Require project_id on VideoRequestBody (404 when unresolvable or not opted into the video engine), thread it through VideoEngine.open_video_task via a shared resolve_authoring_project helper, and resolve the render loop's motion/ workspace from the authoring task's own project_id instead of the hardcoded self_heal_project_slug. * [7f2c881a] fix(video): cast task.id to UUID before VideoEngine.rerender calls mypy flagged task.id as sqlalchemy.sql.sqltypes.UUID[Any] rather than uuid.UUID in the three rerender tests; cast to UUID per the codebase's established idiom (cast("UUID", obj.id)) used elsewhere for the same SQLAlchemy Mapped-attribute inference gap. * [7f2c881a] docs(video): API endpoints for project-scoped requests, re-render, and preview proxy Add comprehensive API documentation for the new project-scoped video engine endpoints: - POST /api/video/request: on-demand video authoring scoped to project_id (breaking change) - POST /api/video/pipeline/{task_id}/rerender: CEO-triggered re-render with idempotency key clearing - GET /api/video/preview/{task_id}/{file_path}: CEO preview proxy with path-traversal confinement Document project-scoping architecture: authoring tasks and render loop now resolve from task's own project_id instead of hardcoded self_heal_project_slug. Add migration guide covering breaking change to VideoRequestBody schema (project_id now required), error handling changes (404 on unresolvable/non-opted-in projects), and client migration steps. --------- Co-authored-by: Backend Developer 1 <be-dev-1@roboco.tech> Co-authored-by: Backend Documenter <be-doc@roboco.tech> * [8f959c3b] docs(ux_ui): add project picker, re-render control, and composition preview panel spec (#381) (#398) Co-authored-by: UX/UI Developer 1 <ux-dev-1@roboco.tech> * [1fb5b5cb] Project picker, re-render button, and composition preview panel (#397) (#402) * [1fb5b5cb] feat(video): project picker, re-render button, and composition preview panel * [1fb5b5cb] docs(video): add comprehensive guide for project picker, re-render button, and composition preview panel --------- Co-authored-by: Frontend Developer 1 <fe-dev-1@roboco.tech> Co-authored-by: Frontend Documenter <fe-doc@roboco.tech> * [a512f364] Add video_engine_enabled to ProjectSummaryResponse (#412) (#414) * [a512f364] feat(api): surface video_engine_enabled on ProjectSummaryResponse * [a512f364] docs(api): document video_engine_enabled on ProjectSummaryResponse --------- Co-authored-by: Backend Developer 1 <be-dev-1@roboco.tech> Co-authored-by: Backend Documenter <be-doc@roboco.tech> * [03607ab9] Fix re-render control gating/placement and project picker filter (#434) * [f2f3e89f] Fix RerenderControl gating/placement across queue and strip views (#431) * [f2f3e89f] feat(video): widen RerenderControl gating and share it across queue/strip views Extracts RerenderControl into a shared panel/src/components/dashboard/ video-rerender-control.tsx component, widens its gate from render_status === 'failed' to source_task_id + composition_id present (matching what the backend rerender endpoint actually requires), adds a confirm dialog before firing the mutation, and wires the same component into video-pipeline-strip.tsx for still-in-flight rendering/render_failed rows. * [f2f3e89f] docs(video): enhance RerenderControl JSDoc with gating logic and usage examples Add comprehensive JSDoc to the RerenderControl component covering its purpose, gating logic (render for any source_task_id + composition_id, regardless of render_status), three visual button states (idle/loading/ error), confirm-dialog guard behavior, and usage examples for both video-post-queue.tsx and video-pipeline-strip.tsx contexts. Explains why the backend's rerender endpoint doesn't require a failed render and how the component prevents accidental re-renders. --------- Co-authored-by: Frontend Developer 1 <fe-dev-1@roboco.tech> Co-authored-by: Frontend Documenter <fe-doc@roboco.tech> * [404d8ed3] Filter project picker to video-engine-enabled projects (#432) * [404d8ed3] feat(panel): filter video-request project picker to opted-in projects Add video_engine_enabled to the client ProjectSummary type, give ProjectSelector a videoEngineOnly filter prop, default RequestVideoDialog's picker to the current video-enabled project with a friendly empty-state when none exist, and cover the filter with a new project-selector test. * [404d8ed3] docs(panel): add ProjectSelector component API reference with videoEngineOnly filter Document the reusable ProjectSelector component with its props, filtering behavior, and new videoEngineOnly filter for video-engine-enabled projects. Follows the existing component documentation pattern from page-refresh-provider. --------- Co-authored-by: Frontend Developer 2 <fe-dev-2@roboco.tech> Co-authored-by: Frontend Documenter <fe-doc@roboco.tech> * [519a4088] fix(panel): import missing RerenderControl in video-post-queue and correct stale doc (#436) Co-authored-by: Frontend Developer 1 <fe-dev-1@roboco.tech> --------- Co-authored-by: Frontend Developer 1 <fe-dev-1@roboco.tech> Co-authored-by: Frontend Documenter <fe-doc@roboco.tech> Co-authored-by: Frontend Developer 2 <fe-dev-2@roboco.tech> * [8e912c3e] Reflow hard-wrapped video UX design doc to pass quality gate (#439) * [ccfe2015] docs(ux_ui): reflow video request composition-controls spec to one line per paragraph (#438) Co-authored-by: UX/UI Developer 1 <ux-dev-1@roboco.tech> * [99c3ed9c] docs(backend): reflow hard-wrapped prose in video-engine-endpoints.md and video-project-scoping.md (#442) Co-authored-by: UX/UI Developer 1 <ux-dev-1@roboco.tech> * [c2e98fc0] docs(backend): strip stray trailing whitespace in video-engine-endpoints.md fence (#451) Co-authored-by: UX/UI Developer 1 <ux-dev-1@roboco.tech> * [9c7bc11a] Reflow all 3 hard-wrapped docs on this branch and verify quality gate (#457) * [9c7bc11a] test(scripts): guard reflow_md.py --check wiring into make quality * [9c7bc11a] docs(standards): document markdown reflow quality gate workflow and verification Added comprehensive guide explaining the one-logical-unit-per-line markdown prose standard, how the reflow check integrates into make quality, the three reflowed files (video-engine-endpoints.md, video-project-scoping.md, composition-controls spec), and the regression test added to ensure wiring stability. This task verifies all three ACs are satisfied: reflow_md.py --check exits 0, make quality passes (non-DB portions), and the three files are whitespace-only reflowed. --------- Co-authored-by: UX/UI Developer 1 <ux-dev-1@roboco.tech> Co-authored-by: UX/UI Documenter <ux-doc@roboco.tech> --------- Co-authored-by: UX/UI Developer 1 <ux-dev-1@roboco.tech> Co-authored-by: UX/UI Documenter <ux-doc@roboco.tech> * [002f0cdd] docs(rag): document reflow-check zero-diff troubleshooting path (#459) (#460) Co-authored-by: Backend Developer 1 <be-dev-1@roboco.tech> * [e4ed92d6] fix rerender missing-task test — assert the empty queue it creates The test never seeds; the trailing assertion expected a phantom video post. Broken since the branch's first commit but never executed — every earlier CI run short-circuited at a pre-pytest gate step. --------- Co-authored-by: Backend Developer 1 <be-dev-1@roboco.tech> Co-authored-by: Backend Documenter <be-doc@roboco.tech> Co-authored-by: UX/UI Developer 1 <ux-dev-1@roboco.tech> Co-authored-by: Frontend Developer 1 <fe-dev-1@roboco.tech> Co-authored-by: Frontend Documenter <fe-doc@roboco.tech> Co-authored-by: Frontend Developer 2 <fe-dev-2@roboco.tech> Co-authored-by: UX/UI Documenter <ux-doc@roboco.tech> Co-authored-by: Renn F <rennf93@users.noreply.github.com>
2026-08-03 07:23:24 +02:00 · 2026-07-11 07:39:17 +02:00
parent 4d52f6ff59
commit 7f138d3bf5
29 changed files with 2707 additions and 107 deletions
@@ -223,6 +223,33 @@ async def test_list_projects_includes_default_branch(
    assert listed[payload["slug"]]["default_branch"] == "master"


+@pytest.mark.asyncio
+async def test_list_projects_includes_video_engine_enabled(
+    project_client: AsyncClient,
+) -> None:
+    payload = _payload()
+    create = await project_client.post("/api/projects", json=payload, headers=_HDR)
+    assert create.status_code == HTTPStatus.CREATED
+
+    default_listed = {
+        p["slug"]: p
+        for p in (await project_client.get("/api/projects", headers=_HDR)).json()
+    }
+    assert default_listed[payload["slug"]]["video_engine_enabled"] is False
+
+    patched = await project_client.patch(
+        f"/api/projects/{payload['slug']}",
+        json={"video_engine_enabled": True},
+        headers=_HDR,
+    )
+    assert patched.status_code == HTTPStatus.OK
+
+    response = await project_client.get("/api/projects", headers=_HDR)
+    assert response.status_code == HTTPStatus.OK
+    listed = {p["slug"]: p for p in response.json()}
+    assert listed[payload["slug"]]["video_engine_enabled"] is True
+
+
@pytest.mark.asyncio
 async def test_get_project_by_slug_not_found(project_client: AsyncClient) -> None:
    response = await project_client.get(
@@ -260,14 +260,17 @@ async def test_request_video_opens_authoring_task(
 ) -> None:
    await _seed(db_session)
    monkeypatch.setattr(cfg, "video_engine_enabled", True)
-    monkeypatch.setattr(cfg, "self_heal_project_slug", SLUG)
    monkeypatch.setattr(cfg, "video_max_open_posts", 5)
+    project = (
+        await db_session.execute(select(ProjectTable).where(ProjectTable.slug == SLUG))
+    ).scalar_one()
    resp = await ceo_client.post(
        "/api/video/request",
        json={
            "occasion": "CEO on-demand: launch teaser",
            "brief": "A short teaser for the new dashboard",
            "platforms": ["x", "tiktok"],
+            "project_id": str(project.id),
        },
    )
    assert resp.status_code == HTTPStatus.OK
@@ -283,6 +286,7 @@ async def test_request_video_opens_authoring_task(
        assert task is not None
        assert task.source == VIDEO_SOURCE
        assert task.status == TaskStatus.PENDING
+        assert task.project_id == project.id
    finally:
        # The route's commit durably persists this task past this test's own
        # rollback teardown — a non-terminal source=video row left behind
@@ -304,7 +308,12 @@ async def test_request_video_disabled_returns_clear_response(
    before = len(await get_task_service(db_session).list_open_video_posts())
    resp = await ceo_client.post(
        "/api/video/request",
-        json={"occasion": "occ-disabled", "brief": "brief", "platforms": ["x"]},
+        json={
+            "occasion": "occ-disabled",
+            "brief": "brief",
+            "platforms": ["x"],
+            "project_id": str(uuid4()),
+        },
    )
    assert resp.status_code == HTTPStatus.OK
    body = resp.json()
@@ -315,27 +324,91 @@ async def test_request_video_disabled_returns_clear_response(


@pytest.mark.asyncio
-async def test_request_video_not_opened_when_project_unresolvable(
+async def test_request_video_404s_on_unresolvable_project_id(
    db_session: AsyncSession, ceo_client: AsyncClient, monkeypatch: pytest.MonkeyPatch
 ) -> None:
-    """An unresolvable project makes open_video_task no-op — a clear
-    ``not_opened`` response, not a 500 or a fabricated task."""
+    """A project_id that doesn't resolve to any project 404s — no fabricated
+    task, no silent not_opened."""
    await _seed(db_session)
    monkeypatch.setattr(cfg, "video_engine_enabled", True)
-    monkeypatch.setattr(cfg, "self_heal_project_slug", "no-such-project")
    before = len(await get_task_service(db_session).list_open_video_posts())
    resp = await ceo_client.post(
        "/api/video/request",
-        json={"occasion": "occ-unresolvable", "brief": "brief", "platforms": ["x"]},
+        json={
+            "occasion": "occ-unresolvable",
+            "brief": "brief",
+            "platforms": ["x"],
+            "project_id": str(uuid4()),
+        },
    )
-    assert resp.status_code == HTTPStatus.OK
-    body = resp.json()
-    assert body["status"] == "not_opened"
-    assert body["task_id"] is None
+    assert resp.status_code == HTTPStatus.NOT_FOUND
    after = len(await get_task_service(db_session).list_open_video_posts())
    assert after == before  # nothing new was opened


+@pytest.mark.asyncio
+async def test_request_video_404s_on_non_opted_in_project_id(
+    db_session: AsyncSession, ceo_client: AsyncClient, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """A project that resolves but hasn't flipped video_engine_enabled also
+    404s, distinct from the unresolvable-project case above."""
+    await _seed(db_session)
+    monkeypatch.setattr(cfg, "video_engine_enabled", True)
+    project = ProjectTable(
+        id=uuid4(),
+        name="Not Opted In",
+        slug=f"not-opted-{uuid4().hex[:6]}",
+        git_url="https://example.com/notopted.git",
+        assigned_cell=Team.BACKEND,
+        created_by=SYSTEM_UUID,
+        video_engine_enabled=False,
+    )
+    db_session.add(project)
+    await db_session.flush()
+    resp = await ceo_client.post(
+        "/api/video/request",
+        json={
+            "occasion": "occ-not-opted",
+            "brief": "brief",
+            "platforms": ["x"],
+            "project_id": str(project.id),
+        },
+    )
+    assert resp.status_code == HTTPStatus.NOT_FOUND
+
+
+@pytest.mark.asyncio
+async def test_request_video_not_opened_on_duplicate_occasion(
+    db_session: AsyncSession, ceo_client: AsyncClient, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """A valid, opted-in project_id still no-ops (not a 404) for a duplicate
+    occasion — the open-cap/dedup reasons stay a clear 200 not_opened."""
+    await _seed(db_session)
+    monkeypatch.setattr(cfg, "video_engine_enabled", True)
+    monkeypatch.setattr(cfg, "video_max_open_posts", 5)
+    project = (
+        await db_session.execute(select(ProjectTable).where(ProjectTable.slug == SLUG))
+    ).scalar_one()
+    payload = {
+        "occasion": "occ-dupe",
+        "brief": "brief",
+        "platforms": ["x"],
+        "project_id": str(project.id),
+    }
+    first = await ceo_client.post("/api/video/request", json=payload)
+    assert first.status_code == HTTPStatus.OK
+    assert first.json()["status"] == "opened"
+    task_id = first.json()["task_id"]
+    try:
+        second = await ceo_client.post("/api/video/request", json=payload)
+        assert second.status_code == HTTPStatus.OK
+        assert second.json()["status"] == "not_opened"
+        assert second.json()["task_id"] is None
+    finally:
+        await db_session.execute(delete(TaskTable).where(TaskTable.id == UUID(task_id)))
+        await db_session.commit()
+
+
@pytest.mark.asyncio
 async def test_list_posts_returns_open_draft(
    db_session: AsyncSession, ceo_client: AsyncClient
@@ -820,7 +893,12 @@ async def test_non_ceo_is_forbidden(db_session: AsyncSession) -> None:
    async with AsyncClient(transport=transport, base_url="http://test") as client:
        request_resp = await client.post(
            "/api/video/request",
-            json={"occasion": "occ", "brief": "brief", "platforms": ["x"]},
+            json={
+                "occasion": "occ",
+                "brief": "brief",
+                "platforms": ["x"],
+                "project_id": str(uuid4()),
+            },
        )
        list_resp = await client.get("/api/video/posts")
        media_resp = await client.get(f"/api/video/posts/{task.id}/media?cut=vertical")
@@ -977,3 +1055,220 @@ async def test_media_falls_back_to_local_file_when_minio_missing(
        assert resp.headers["content-type"] == "video/mp4"
        assert resp.content == b"local-file-bytes"  # FileResponse fallback, not MinIO
    app.dependency_overrides.clear()
+
+
+# --- re-render (task 3, 2026-07-10) -------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_rerender_clears_state_and_returns_pipeline_item(
+    db_session: AsyncSession, ceo_client: AsyncClient
+) -> None:
+    task = await _seed_authoring_task(
+        db_session,
+        status=TaskStatus.COMPLETED,
+        draft_extra={
+            "composition_id": "Intro",
+            "render_status": "failed",
+            "render_attempts": markers.MAX_VIDEO_RENDER_ATTEMPTS,
+            "render_error": "sidecar timeout",
+        },
+    )
+    resp = await ceo_client.post(f"/api/video/pipeline/{task.id}/rerender")
+    assert resp.status_code == HTTPStatus.OK
+    body = resp.json()
+    assert body["task_id"] == str(task.id)
+    assert body["render_status"] is None
+    assert body["render_attempts"] == 0
+    assert body["render_error"] is None
+    draft = markers.get_video_draft(task)
+    assert draft is not None
+    assert "render_status" not in draft
+    assert "render_attempts" not in draft
+    assert "render_error" not in draft
+    assert draft["composition_id"] == "Intro"  # everything else preserved
+
+
+@pytest.mark.asyncio
+async def test_rerender_missing_task_is_404(ceo_client: AsyncClient) -> None:
+    resp = await ceo_client.post(f"/api/video/pipeline/{uuid4()}/rerender")
+    assert resp.status_code == HTTPStatus.NOT_FOUND
+
+
+@pytest.mark.asyncio
+async def test_rerender_non_completed_task_is_404(
+    db_session: AsyncSession, ceo_client: AsyncClient
+) -> None:
+    task = await _seed_authoring_task(
+        db_session,
+        status=TaskStatus.IN_PROGRESS,
+        draft_extra={"composition_id": "Intro"},
+    )
+    resp = await ceo_client.post(f"/api/video/pipeline/{task.id}/rerender")
+    assert resp.status_code == HTTPStatus.NOT_FOUND
+
+
+@pytest.mark.asyncio
+async def test_rerender_without_composition_id_is_404(
+    db_session: AsyncSession, ceo_client: AsyncClient
+) -> None:
+    task = await _seed_authoring_task(db_session, status=TaskStatus.COMPLETED)
+    resp = await ceo_client.post(f"/api/video/pipeline/{task.id}/rerender")
+    assert resp.status_code == HTTPStatus.NOT_FOUND
+
+
+@pytest.mark.asyncio
+async def test_rerender_non_ceo_is_forbidden(db_session: AsyncSession) -> None:
+    task = await _seed_authoring_task(
+        db_session,
+        status=TaskStatus.COMPLETED,
+        draft_extra={"composition_id": "Intro"},
+    )
+    app = _build_app(db_session, AgentRole.DEVELOPER, uuid4())
+    transport = ASGITransport(app=app)
+    async with AsyncClient(transport=transport, base_url="http://test") as client:
+        resp = await client.post(f"/api/video/pipeline/{task.id}/rerender")
+    assert resp.status_code == HTTPStatus.FORBIDDEN
+    app.dependency_overrides.clear()
+
+
+# --- preview proxy (task 3, 2026-07-10) ---------------------------------------
+
+
+def _fake_workspace_service(root: Path) -> object:
+    """A ``get_workspace_service``-shaped stub whose ``ensure_read_clone``
+    returns a fixed local dir — no real git clone touched."""
+
+    class _Svc:
+        async def ensure_read_clone(self, _slug: str, *, force: bool = False) -> Path:
+            _ = force
+            return root
+
+    return _Svc()
+
+
+def test_resolve_preview_path_serves_file_inside_root(tmp_path: Path) -> None:
+    root = (tmp_path / "clone").resolve()
+    (root / "motion" / "compositions" / "Intro").mkdir(parents=True)
+    target = root / "motion" / "compositions" / "Intro" / "vertical.html"
+    target.write_text("<html></html>")
+    resolved = video_module._resolve_preview_path(
+        root, "motion/compositions/Intro/vertical.html"
+    )
+    assert resolved == target.resolve()
+
+
+def test_resolve_preview_path_blocks_dot_dot_traversal(tmp_path: Path) -> None:
+    root = (tmp_path / "clone").resolve()
+    (root / "motion").mkdir(parents=True)
+    secret = tmp_path / "secret.txt"
+    secret.write_text("nope")
+    assert video_module._resolve_preview_path(root, "../secret.txt") is None
+    assert video_module._resolve_preview_path(root, "motion/../../secret.txt") is None
+
+
+def test_resolve_preview_path_blocks_absolute_path_override(tmp_path: Path) -> None:
+    """A leading '/' in file_path would otherwise let pathlib's ``/``
+    operator discard ``root`` entirely and resolve straight to the absolute
+    path — the ``lstrip("/")`` guard neutralizes that."""
+    root = (tmp_path / "clone").resolve()
+    root.mkdir()
+    outside = tmp_path / "outside.txt"
+    outside.write_text("nope")
+    assert video_module._resolve_preview_path(root, str(outside)) is None
+
+
+def test_resolve_preview_path_missing_file_is_none(tmp_path: Path) -> None:
+    root = (tmp_path / "clone").resolve()
+    root.mkdir()
+    assert video_module._resolve_preview_path(root, "motion/nope.html") is None
+
+
+@pytest.mark.asyncio
+async def test_preview_serves_composition_html_and_sibling_kit_asset(
+    db_session: AsyncSession,
+    ceo_client: AsyncClient,
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    comp_dir = tmp_path / "motion" / "compositions" / "Intro"
+    comp_dir.mkdir(parents=True)
+    (comp_dir / "vertical.html").write_text("<html>intro</html>")
+    kit_dir = tmp_path / "motion" / "kit"
+    kit_dir.mkdir(parents=True)
+    (kit_dir / "kit.css").write_text("body{}")
+    monkeypatch.setattr(
+        video_module,
+        "get_workspace_service",
+        lambda _db: _fake_workspace_service(tmp_path),
+    )
+    task = await _seed_authoring_task(
+        db_session,
+        status=TaskStatus.IN_PROGRESS,
+        draft_extra={"composition_id": "Intro"},
+    )
+    resp = await ceo_client.get(
+        f"/api/video/preview/{task.id}/motion/compositions/Intro/vertical.html"
+    )
+    assert resp.status_code == HTTPStatus.OK
+    assert resp.text == "<html>intro</html>"
+    assert resp.headers.get("x-frame-options") == "SAMEORIGIN"
+    assert "frame-ancestors" in resp.headers.get("content-security-policy", "")
+
+    kit_resp = await ceo_client.get(f"/api/video/preview/{task.id}/motion/kit/kit.css")
+    assert kit_resp.status_code == HTTPStatus.OK
+    assert kit_resp.text == "body{}"
+
+
+@pytest.mark.asyncio
+async def test_preview_missing_file_is_404(
+    db_session: AsyncSession,
+    ceo_client: AsyncClient,
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    (tmp_path / "motion").mkdir()
+    monkeypatch.setattr(
+        video_module,
+        "get_workspace_service",
+        lambda _db: _fake_workspace_service(tmp_path),
+    )
+    task = await _seed_authoring_task(
+        db_session,
+        status=TaskStatus.IN_PROGRESS,
+        draft_extra={"composition_id": "Intro"},
+    )
+    resp = await ceo_client.get(
+        f"/api/video/preview/{task.id}/motion/compositions/Intro/vertical.html"
+    )
+    assert resp.status_code == HTTPStatus.NOT_FOUND
+
+
+@pytest.mark.asyncio
+async def test_preview_missing_task_is_404(ceo_client: AsyncClient) -> None:
+    resp = await ceo_client.get(f"/api/video/preview/{uuid4()}/vertical.html")
+    assert resp.status_code == HTTPStatus.NOT_FOUND
+
+
+@pytest.mark.asyncio
+async def test_preview_non_video_task_is_404(
+    db_session: AsyncSession, ceo_client: AsyncClient
+) -> None:
+    task = await _seed_draft(db_session)  # source=video_post, not video
+    resp = await ceo_client.get(f"/api/video/preview/{task.id}/vertical.html")
+    assert resp.status_code == HTTPStatus.NOT_FOUND
+
+
+@pytest.mark.asyncio
+async def test_preview_non_ceo_is_forbidden(db_session: AsyncSession) -> None:
+    task = await _seed_authoring_task(
+        db_session,
+        status=TaskStatus.IN_PROGRESS,
+        draft_extra={"composition_id": "Intro"},
+    )
+    app = _build_app(db_session, AgentRole.DEVELOPER, uuid4())
+    transport = ASGITransport(app=app)
+    async with AsyncClient(transport=transport, base_url="http://test") as client:
+        resp = await client.get(f"/api/video/preview/{task.id}/vertical.html")
+    assert resp.status_code == HTTPStatus.FORBIDDEN
+    app.dependency_overrides.clear()
@@ -42,6 +42,7 @@ UX_DEV_2_UUID = _foundation.AGENTS["ux-dev-2"].uuid
 SLUG = "roboco"
 ONE = 1
 TWO = 2
+FOUR = 4


 def _orch() -> Any:
@@ -333,6 +334,35 @@ async def test_render_video_task_renders_both_cuts_and_materializes_post(
    assert source_draft["render_status"] == "rendered"


+@pytest.mark.asyncio
+async def test_render_video_task_resolves_workspace_from_task_project_not_settings(
+    db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """The render loop resolves the read-clone from the authoring task's OWN
+    project_id — flipping self_heal_project_slug to a bogus value AFTER the
+    task was authored must not affect the render, proving the loop no longer
+    reads that setting live."""
+    await _seed(db_session)
+    _enable(monkeypatch)
+    task = await _make_completed_video_task(
+        db_session, occasion="own-project-not-settings", composition_id="Intro"
+    )
+    monkeypatch.setattr(cfg, "self_heal_project_slug", "no-such-project-anymore")
+
+    renderer = _FakeRenderer()
+    workspace = _fake_workspace()
+    orch = _orch()
+    p1, p2 = _render_patches(renderer, workspace)
+    with p1, p2:
+        await orch._render_video_task(db_session, task)
+
+    # Still resolved via the task's own project_id -> slug "roboco", not the
+    # now-bogus self_heal_project_slug.
+    workspace.ensure_read_clone.assert_awaited_once_with(SLUG)
+    posts = await get_task_service(db_session).list_open_video_posts()
+    assert len(posts) == ONE
+
+
@pytest.mark.asyncio
 async def test_render_video_task_second_call_is_idempotent(
    db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
@@ -356,6 +386,45 @@ async def test_render_video_task_second_call_is_idempotent(
    assert len(posts) == ONE


+@pytest.mark.asyncio
+async def test_rerender_clears_state_so_next_cycle_re_renders(
+    db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """CEO re-render flow end to end: a rendered task is a no-op on a second
+    render pass (idempotent); clearing render_status/render_attempts via
+    VideoEngine.rerender makes the NEXT pass pick it up and render it again."""
+    await _seed(db_session)
+    _enable(monkeypatch)
+    task = await _make_completed_video_task(
+        db_session, occasion="rerender-cycle", composition_id="Intro"
+    )
+
+    renderer = _FakeRenderer()
+    workspace = _fake_workspace()
+    orch = _orch()
+    p1, p2 = _render_patches(renderer, workspace)
+    with p1, p2:
+        await orch._render_video_task(db_session, task)
+    assert len(renderer.calls) == TWO
+    draft = markers.get_video_draft(task)
+    assert draft is not None
+    assert draft["render_status"] == "rendered"
+
+    rerendered = await VideoEngine(db_session).rerender(task.id)
+    assert rerendered is not None
+    draft = markers.get_video_draft(task)
+    assert draft is not None
+    assert "render_status" not in draft
+    assert "render_attempts" not in draft
+
+    with p1, p2:
+        await orch._render_video_task(db_session, task)  # re-picked up
+    assert len(renderer.calls) == FOUR  # rendered a second time, not skipped
+    draft = markers.get_video_draft(task)
+    assert draft is not None
+    assert draft["render_status"] == "rendered"
+
+
@pytest.mark.asyncio
 async def test_render_video_task_skips_task_without_composition_id(
    db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
@@ -0,0 +1,56 @@
+"""Guard the hard-wrap reflow gate: wiring into `make quality` + the check exit code.
+
+Nothing previously pinned that `make quality` actually runs
+`scripts/reflow_md.py --check` — a `Makefile` edit could silently drop the
+line and no test would notice the regression. These tests pin the wiring and
+the script's own pass/fail exit codes behind the I/O shell.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).parents[3]
+SCRIPT = ROOT / "scripts" / "reflow_md.py"
+MAKEFILE = ROOT / "Makefile"
+
+
+def test_quality_target_wires_in_reflow_check() -> None:
+    text = MAKEFILE.read_text()
+    quality_block = text.split("\n.PHONY: quality\n", 1)[1].split("\n.PHONY: ", 1)[0]
+    assert "scripts/reflow_md.py --check" in quality_block, (
+        "make quality must run scripts/reflow_md.py --check "
+        "(the hard-wrap reflow gate) — wiring was removed"
+    )
+
+
+def test_check_passes_on_repo_as_committed() -> None:
+    result = subprocess.run(
+        [sys.executable, str(SCRIPT), "--check"],
+        cwd=ROOT,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    assert result.returncode == 0, result.stdout + result.stderr
+    assert "OK: no hard-wrapped markdown prose in scope." in result.stdout
+
+
+def test_check_fails_on_a_hard_wrapped_file(tmp_path: Path) -> None:
+    wrapped = tmp_path / "sample.md"
+    wrapped.write_text(
+        "This is a paragraph that has been\n"
+        "hard-wrapped mid-sentence across two\n"
+        "separate lines for no good reason.\n"
+    )
+    result = subprocess.run(
+        [sys.executable, str(SCRIPT), "--check"],
+        cwd=tmp_path,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    assert result.returncode == 1
+    assert "hard-wrapped prose" in result.stdout
@@ -8,8 +8,9 @@ Secretary-owned and held for the CEO. Asserted against a real Postgres DB.

 from __future__ import annotations

-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, cast
 from unittest.mock import AsyncMock
+from uuid import UUID, uuid4

 import pytest
 from roboco.config import settings as cfg
@@ -307,6 +308,93 @@ async def test_open_video_task_insert_error_returns_none_session_usable(
    assert check.scalar_one_or_none() is not None


+# --------------------------------------------------------------------------- #
+# open_video_task(project_id=...) — the on-demand caller's own project scope
+# --------------------------------------------------------------------------- #
+
+
+@pytest.mark.asyncio
+async def test_open_video_task_with_explicit_project_id_ignores_self_heal_slug(
+    db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """A caller-supplied project_id resolves independent of
+    self_heal_project_slug — the authoring task lands on THAT project, not
+    the fixed RoboCo one."""
+    await _seed(db_session)
+    _enable(monkeypatch)
+    other = ProjectTable(
+        name="Other Repo",
+        slug="other-repo",
+        git_url="https://github.com/x/other.git",
+        default_branch="master",
+        protected_branches=["master"],
+        assigned_cell=Team.BACKEND,
+        created_by=SYSTEM_UUID,
+        is_active=True,
+        video_engine_enabled=True,
+    )
+    db_session.add(other)
+    await db_session.flush()
+    monkeypatch.setattr(cfg, "self_heal_project_slug", "no-such-slug")
+    engine = video_engine_module.VideoEngine(db_session)
+    task = await engine.open_video_task(
+        occasion="on-demand other repo",
+        script="s",
+        platforms=["x"],
+        brief="b",
+        project_id=cast("UUID", other.id),
+    )
+    assert task is not None
+    assert task.project_id == other.id
+
+
+@pytest.mark.asyncio
+async def test_open_video_task_explicit_project_id_not_opted_in_opens_nothing(
+    db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    await _seed(db_session)
+    _enable(monkeypatch)
+    other = ProjectTable(
+        name="Not Opted In",
+        slug="not-opted-in",
+        git_url="https://github.com/x/notopted.git",
+        default_branch="master",
+        protected_branches=["master"],
+        assigned_cell=Team.BACKEND,
+        created_by=SYSTEM_UUID,
+        is_active=True,
+        video_engine_enabled=False,
+    )
+    db_session.add(other)
+    await db_session.flush()
+    engine = video_engine_module.VideoEngine(db_session)
+    task = await engine.open_video_task(
+        occasion="on-demand not opted",
+        script="s",
+        platforms=["x"],
+        brief="b",
+        project_id=cast("UUID", other.id),
+    )
+    assert task is None
+
+
+@pytest.mark.asyncio
+async def test_open_video_task_explicit_project_id_unresolvable_opens_nothing(
+    db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    await _seed(db_session)
+    _enable(monkeypatch)
+    engine = video_engine_module.VideoEngine(db_session)
+    task = await engine.open_video_task(
+        occasion="on-demand missing project",
+        script="s",
+        platforms=["x"],
+        brief="b",
+        project_id=uuid4(),
+    )
+    assert task is None
+
+
 # --------------------------------------------------------------------------- #
 # _originate_video_post
 # --------------------------------------------------------------------------- #
@@ -644,5 +732,89 @@ async def test_draft_release_video_dedupes_same_version(
    second = await engine.draft_release_video(version="1.0.0", changelog=_CHANGELOG)
    assert first is not None
    assert second is None
+
+
+# --------------------------------------------------------------------------- #
+# rerender — CEO-triggered clear of the render idempotency keys
+# --------------------------------------------------------------------------- #
+
+
+@pytest.mark.asyncio
+async def test_rerender_clears_render_state_keeps_the_rest(
+    db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    await _seed(db_session)
+    _enable(monkeypatch)
+    engine = video_engine_module.VideoEngine(db_session)
+    task = await engine.open_video_task(
+        occasion="rerender-me", script="s", platforms=["x"], brief="b"
+    )
+    assert task is not None
+    draft = markers.get_video_draft(task) or {}
+    markers.set_video_draft(
+        task,
+        {
+            **draft,
+            "composition_id": "Intro",
+            "render_status": "failed",
+            "render_attempts": THREE,
+            "render_error": "sidecar timeout",
+        },
+    )
+    task.status = TS.COMPLETED
+    await db_session.flush()
+
+    result = await engine.rerender(cast("UUID", task.id))
+    assert result is not None
+    cleared = markers.get_video_draft(result)
+    assert cleared is not None
+    assert "render_status" not in cleared
+    assert "render_attempts" not in cleared
+    assert "render_error" not in cleared
+    assert cleared["composition_id"] == "Intro"  # everything else preserved
+
+
+@pytest.mark.asyncio
+async def test_rerender_none_for_non_completed_task(
+    db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    await _seed(db_session)
+    _enable(monkeypatch)
+    engine = video_engine_module.VideoEngine(db_session)
+    task = await engine.open_video_task(
+        occasion="not-yet-done", script="s", platforms=["x"], brief="b"
+    )
+    assert task is not None
+    draft = markers.get_video_draft(task) or {}
+    markers.set_video_draft(task, {**draft, "composition_id": "Intro"})
+    await db_session.flush()  # still PENDING, not COMPLETED
+
+    result = await engine.rerender(cast("UUID", task.id))
+    assert result is None
+
+
+@pytest.mark.asyncio
+async def test_rerender_none_without_composition_id(
+    db_session: AsyncSession, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    await _seed(db_session)
+    _enable(monkeypatch)
+    engine = video_engine_module.VideoEngine(db_session)
+    task = await engine.open_video_task(
+        occasion="no-composition-yet", script="s", platforms=["x"], brief="b"
+    )
+    assert task is not None
+    task.status = TS.COMPLETED
+    await db_session.flush()  # no propose_video call yet -> no composition_id
+
+    result = await engine.rerender(cast("UUID", task.id))
+    assert result is None
+
+
+@pytest.mark.asyncio
+async def test_rerender_none_for_missing_task(db_session: AsyncSession) -> None:
+    engine = video_engine_module.VideoEngine(db_session)
+    result = await engine.rerender(uuid4())
+    assert result is None
    open_tasks = await get_task_service(db_session).list_open_video_posts()
-    assert len(open_tasks) == ONE
+    assert open_tasks == []