From a752fb2af1734b7440045ff835e82b7bab127500 Mon Sep 17 00:00:00 2001
From: LoopX Agent <337587101+loopx-agent@users.noreply.github.com>
Date: Mon, 19 Oct 2026 12:53:34 +0800
Subject: [PATCH 1/9] feat(content-ops): render private compositions through
 optional media provider

Signed-off-by: LoopX Agent <337587101+loopx-agent@users.noreply.github.com>
---
 .../capability-localization.ts                |   4 +-
 .../content-media-workbench.css               |  25 ++
 .../content-media-workbench.tsx               |  89 ++++++
 .../goal-capability-settings.tsx              |   9 +-
 .../personal-workspace/memory-settings.tsx    |   4 +-
 docs/reference/protocols/README.md            |   1 +
 .../protocols/content-ops-media-v0.md         | 117 +++++++
 .../protocols/content-ops-reference-v0.md     |   2 +-
 examples/content-ops-media-brief.json         |  17 +
 loopx/capabilities/content_ops/README.md      |  19 +-
 loopx/capabilities/content_ops/cli.py         |   5 +
 loopx/capabilities/content_ops/media.py       | 268 ++++++++++++++++
 loopx/capabilities/content_ops/media_cli.py   |  38 +++
 loopx/capabilities/content_ops/reference.py   |   4 +-
 .../capabilities/content_media.ts             | 157 +++++++++
 .../control_plane/effect_runtime_handlers.ts  |   3 +
 loopx/presentation/configuration_api.py       |   4 +
 loopx/presentation/content_media_api.py       |  88 +++++
 packages/loopx-media/README.md                |  90 ++++++
 packages/loopx-media/extension.toml           |  16 +
 packages/loopx-media/pyproject.toml           |  16 +
 .../loopx-media/src/loopx_media/__init__.py   |   1 +
 .../loopx-media/src/loopx_media/renderer.py   | 301 ++++++++++++++++++
 tests/control_plane_ts/content_media.test.ts  |  71 +++++
 tests/test_content_media.py                   | 218 +++++++++++++
 25 files changed, 1551 insertions(+), 16 deletions(-)
 create mode 100644 apps/presentation/dashboard/src/features/personal-workspace/content-media-workbench.css
 create mode 100644 apps/presentation/dashboard/src/features/personal-workspace/content-media-workbench.tsx
 create mode 100644 docs/reference/protocols/content-ops-media-v0.md
 create mode 100644 examples/content-ops-media-brief.json
 create mode 100644 loopx/capabilities/content_ops/media.py
 create mode 100644 loopx/capabilities/content_ops/media_cli.py
 create mode 100644 loopx/control_plane/capabilities/content_media.ts
 create mode 100644 loopx/presentation/content_media_api.py
 create mode 100644 packages/loopx-media/README.md
 create mode 100644 packages/loopx-media/extension.toml
 create mode 100644 packages/loopx-media/pyproject.toml
 create mode 100644 packages/loopx-media/src/loopx_media/__init__.py
 create mode 100644 packages/loopx-media/src/loopx_media/renderer.py
 create mode 100644 tests/control_plane_ts/content_media.test.ts
 create mode 100644 tests/test_content_media.py

diff --git a/apps/presentation/dashboard/src/features/personal-workspace/capability-localization.ts b/apps/presentation/dashboard/src/features/personal-workspace/capability-localization.ts
index 326d3714bf..df3dbe8a60 100644
--- a/apps/presentation/dashboard/src/features/personal-workspace/capability-localization.ts
+++ b/apps/presentation/dashboard/src/features/personal-workspace/capability-localization.ts
@@ -14,7 +14,7 @@ const capabilityCopy: Record<WorkspaceLocale, Record<string, LocalizedCopy>> = {
   en: {
     codex_chat: {displayName: "Codex Goal conversation defaults", description: "Choose the native Codex profile, model, speed tier and reasoning effort for new Goal conversations. Existing conversations keep their original history. This does not start or reconfigure an active Agent Loop, worker or steward."},
     decision_context: {displayName: "Find evidence", description: "Find advisory evidence with a temporary private profile. OpenViking and BM25 are retrieval implementations; this page does not save a binding or enable automatic memory."},
-    content_ops: {displayName: "Reference styles", description: "Retrieve source styles from an existing private catalog and prepare attributed outlines. No source or material-store writes."},
+    content_ops: {displayName: "Content production", description: "Prepare source-backed outlines and local videos. Review the result before sharing; rendering uses an optional local extension."},
     goal_storage: { displayName: "New Goal authority", description: "New Goals default to canonical SQLite with hard leases. Choose storage and execution policy for future Goals. Existing Goals require a separate backed-up migration." },
     manager_runtime: {
       displayName: "Runtime",
@@ -83,7 +83,7 @@ const capabilityCopy: Record<WorkspaceLocale, Record<string, LocalizedCopy>> = {
   "zh-CN": {
     codex_chat: {displayName: "Codex Goal 对话默认值", description: "分别选择 Codex 配置来源、模型、速度档和推理强度，作用于本机的新 Goal 对话。已有对话保留原历史；不会启动或重配正在运行的 Agent Loop、工作 Agent 或管家。"},
     decision_context: {displayName: "资料召回", description: "通过临时私有配置查找参考证据。OpenViking、BM25 是检索实现；本页不保存绑定，也不启用自动记忆。"},
-    content_ops: {displayName: "素材与风格", description: "从原有私有目录检索表达结构，准备带来源署名的提纲；不执行来源或素材库写入。"},
+    content_ops: {displayName: "内容制作", description: "准备有来源的提纲与本机视频，检查作品后再分享；视频制作使用可选本机扩展。"},
     goal_storage: { displayName: "新 Goal 的权威存储", description: "新 Goal 默认使用 canonical SQLite 与 hard lease；可选择之后新 Goal 的存储与执行策略。已有 Goal 仍需单独备份、迁移。" },
     manager_runtime: {
       displayName: "运行环境",
diff --git a/apps/presentation/dashboard/src/features/personal-workspace/content-media-workbench.css b/apps/presentation/dashboard/src/features/personal-workspace/content-media-workbench.css
new file mode 100644
index 0000000000..1d085b85f0
--- /dev/null
+++ b/apps/presentation/dashboard/src/features/personal-workspace/content-media-workbench.css
@@ -0,0 +1,25 @@
+.content-production-panel {padding:0 24px 24px;}
+.content-media {padding:16px 0 24px; border-bottom:1px solid var(--border, #e5e7eb);}
+.content-media-heading, .content-media-title {display:flex; justify-content:space-between; align-items:flex-start; gap:16px;}
+.content-media h3, .content-media h4 {margin:0 0 6px; font-size:16px; font-weight:600;}
+.content-media p {margin:6px 0 14px; color:var(--muted-foreground, #666); font-size:13px; line-height:1.6;}
+.content-media button {min-height:44px; border:1px solid var(--border, #dce0e5); border-radius:7px; padding:8px 12px; background:var(--background, white); color:inherit; cursor:pointer; font:inherit; font-size:13px;}
+.content-media button:disabled {opacity:.5; cursor:default;}
+.content-media button:focus-visible, .content-media a:focus-visible {outline:2px solid var(--accent, #2768ea); outline-offset:3px;}
+.content-media-notice {padding:10px 12px; background:var(--muted, #f4f5f6); border-left:2px solid #8a95a5;}
+.content-media-workspace {display:grid; grid-template-columns:minmax(130px, 180px) minmax(0, 1fr); gap:20px; margin-top:20px;}
+.content-media nav {display:flex; flex-direction:column; gap:5px;}
+.content-media nav button {text-align:left; border-color:transparent; display:grid; gap:6px;}
+.content-media nav button[aria-pressed=true] {background:var(--muted, #f2f4f7); border-color:var(--border, #dce0e5);}
+.content-media small {display:block; color:var(--muted-foreground, #687080); font-size:11px; line-height:1.5;}
+.content-media-result {min-width:0;}
+.content-media-result video {display:block; width:100%; margin:14px 0; border-radius:8px; background:#f5f7fb;}
+.content-media-timeline {list-style:none; padding:0; margin:14px 0; border-top:1px solid var(--border, #e5e7eb);}
+.content-media-timeline li {padding:12px 0; border-bottom:1px solid var(--border, #e5e7eb); font-size:13px;}
+.content-media-timeline small {margin-top:4px;}
+.content-media-downloads {display:flex; gap:16px; flex-wrap:wrap; font-size:13px;}
+.content-media details {font-size:12px; margin-top:18px;}
+.content-media details summary {cursor:pointer; color:var(--muted-foreground, #687080);}
+.content-media details li {line-height:1.6; margin:6px 0;}
+.content-media-empty {padding:22px 0;}
+@media(max-width:680px) {.content-production-panel {padding:0 16px 20px;}.content-media-workspace {grid-template-columns:minmax(0, 1fr);}.content-media nav {flex-direction:row; overflow-x:auto;}.content-media nav button {min-width:160px;}.content-media-heading, .content-media-title {flex-wrap:wrap;}}
diff --git a/apps/presentation/dashboard/src/features/personal-workspace/content-media-workbench.tsx b/apps/presentation/dashboard/src/features/personal-workspace/content-media-workbench.tsx
new file mode 100644
index 0000000000..8b6e1c7405
--- /dev/null
+++ b/apps/presentation/dashboard/src/features/personal-workspace/content-media-workbench.tsx
@@ -0,0 +1,89 @@
+import {useEffect, useRef, useState} from "react";
+import {useWorkspaceI18n} from "./i18n";
+import "./content-media-workbench.css";
+
+type Provider = {status: string; enabled: boolean | null; next_action: string | null};
+type Composition = {
+  composition_id: string; revision: number; status: string; title: string; duration_seconds: number;
+  shots: {title: string; seconds: number; kind: string; boundary: string; source_ref: string}[];
+  result: {files: Record<string, {sha256: string; bytes: number}>; qa: {frames: number; full_decode: string; narration: {mode: string}}; cost: {render_wall_seconds: number}} | null;
+  provider: Provider;
+};
+type Library = {ok: boolean; compositions: Composition[]; provider: Provider};
+const ENDPOINT = "/api/chat/content-media";
+
+export function ContentMediaWorkbench({goalId}: {goalId: string}) {
+  const {locale} = useWorkspaceI18n();
+  const copy = (cn: string, en: string) => locale === "zh-CN" ? cn : en;
+  const [library, setLibrary] = useState<Library | null>(null), [selectedId, setSelectedId] = useState("");
+  const [error, setError] = useState(""), [busy, setBusy] = useState(false);
+  const pending = useRef(false), generation = useRef(0), readSequence = useRef(0);
+  const selected = library?.compositions.find(item => item.composition_id === selectedId) ?? library?.compositions[0];
+  async function request(action: string, item?: Composition) {
+    const response = await fetch(ENDPOINT, {method: "POST", headers: {"Content-Type": "application/json"},
+      body: JSON.stringify({goal_id: goalId, action, ...(item ? {composition_id: item.composition_id, expected_revision: item.revision} : {})})});
+    if (!response.ok) throw new Error();
+    return await response.json();
+  }
+  async function reload() {
+    const current = generation.current;
+    const sequence = ++readSequence.current;
+    try {
+      const value: Library = await request("list");
+      if (current === generation.current && sequence === readSequence.current) {setLibrary(value); setError("");}
+    } catch {if (current === generation.current && sequence === readSequence.current) setError(copy("作品暂不可读，请重新读取。", "Cannot read compositions. Recheck the workspace."));}
+  }
+  useEffect(() => {
+    generation.current += 1; setLibrary(null); setSelectedId(""); pending.current = false; setBusy(false); void reload();
+    return () => {generation.current += 1;};
+  }, [goalId]);
+  const running = library?.compositions.some(item => item.status === "rendering");
+  useEffect(() => {
+    if (!running) return;
+    const timer = setInterval(() => void reload(), 2000);
+    return () => clearInterval(timer);
+  }, [running, goalId]);
+  async function operate(action: "render" | "cancel") {
+    if (!selected || pending.current) return;
+    pending.current = true; setBusy(true); setError("");
+    const current = generation.current;
+    try {
+      const value = await request(action, selected);
+      if (current !== generation.current) return;
+      await reload();
+      if (!value.ok) setError(copy("渲染器未就绪。请启用已验证的本机视频扩展后重试。", "Renderer unavailable. Enable the verified local video extension, then retry."));
+    } catch {if (current === generation.current) setError(copy("操作未确认。先重新读取，避免重复启动。", "Operation unconfirmed. Recheck before retrying."));}
+    finally {if (current === generation.current) {pending.current = false; setBusy(false);}}
+  }
+  function file(name: string) {return `${ENDPOINT}/file?${new URLSearchParams({goal_id: goalId, composition_id: selected!.composition_id, file: name})}`;}
+  const status: Record<string, string> = {
+    prepared: copy("待制作", "Ready to render"), rendering: copy("正在制作", "Rendering"), ready: copy("作品已生成", "Video ready"),
+    failed: copy("制作失败，可修复后重试", "Render failed; repair and retry"), cancelled: copy("已取消，可重新制作", "Cancelled; ready to retry"),
+    interrupted: copy("上次制作中断，可重新制作", "Previous render interrupted; retry available"), damaged: copy("结果校验失败，请重新制作", "Result verification failed; render again"),
+  };
+  const providerReady = library?.provider.status === "ready";
+  return <section className="content-media" aria-label={copy("视频制作", "Video production")}>
+    <div className="content-media-heading"><div><h3>{copy("制作视频", "Produce a video")}</h3>
+      <p>{copy("让 Agent 准备脚本、来源和时间线，在这里制作并查看作品。", "Have your Agent prepare the story, sources and timeline. Render and review the result here.")}</p></div>
+      <button type="button" onClick={() => void reload()} disabled={busy}>{copy("重新读取", "Recheck")}</button></div>
+    {error ? <p role="alert">{error}</p> : null}
+    {!library && !error ? <p role="status">{copy("正在读取作品…", "Loading compositions…")}</p> : null}
+    {library && !providerReady ? <p className="content-media-notice" role="status">{copy("本机视频扩展未就绪。作品与来源保留，安装并启用 loopx-media 后即可制作。", "The local video extension is unavailable. Prepared work is retained; install and enable loopx-media to render.")}</p> : null}
+    {library && !selected ? <p className="content-media-empty">{copy("还没有准备好的作品。把想讲的内容交给 Agent，它会通过 Content-Ops 保存可制作的脚本。", "No prepared compositions yet. Tell your Agent what to explain; it can save a renderable brief through Content-Ops.")}</p> : null}
+    {selected ? <div className="content-media-workspace">
+      <nav aria-label={copy("选择作品", "Choose a composition")}>{library!.compositions.map(item => <button key={item.composition_id} type="button" aria-pressed={item.composition_id === selected.composition_id}
+        onClick={() => setSelectedId(item.composition_id)}><span>{item.title}</span><small>{item.duration_seconds}s · {status[item.status] ?? item.status}</small></button>)}</nav>
+      <div className="content-media-result"><div className="content-media-title"><div><h4>{selected.title}</h4><p role="status">{status[selected.status] ?? selected.status} · {selected.duration_seconds}s · {copy("修订", "Revision")} {selected.revision}</p></div>
+        {selected.status === "rendering" ? <button type="button" disabled={busy} onClick={() => void operate("cancel")}>{copy("取消制作", "Cancel render")}</button>
+          : <button type="button" disabled={busy || !providerReady || selected.status === "ready"} onClick={() => void operate("render")}>{copy("制作视频", "Render video")}</button>}</div>
+        {selected.status === "ready" && selected.result ? <><video key={`${selected.composition_id}:${selected.result.files["video.mp4"].sha256}`} controls preload="metadata" poster={file("poster.png")} src={file("video.mp4")}>
+          <track kind="captions" src={file("captions.vtt")} label={copy("字幕", "Captions")} default /></video>
+          <div className="content-media-downloads"><a href={file("video.mp4")} download="video.mp4">{copy("下载视频", "Download video")}</a><a href={file("captions.srt")} download="captions.srt">{copy("字幕", "Subtitles")}</a><a href={file("transcript.txt")} download="transcript.txt">{copy("文字稿", "Transcript")}</a></div>
+          <p>{copy("完整解码通过", "Full decode passed")} · {selected.result.qa.frames} {copy("帧", "frames")} · {copy("渲染耗时", "Render time")} {selected.result.cost.render_wall_seconds}s</p>
+        </> : <ol className="content-media-timeline">{selected.shots.map((shot, i) => <li key={i}><span>{shot.title}</span><small>{shot.seconds}s · {shot.boundary}</small></li>)}</ol>}
+        {["failed", "damaged"].includes(selected.status) ? <p>{copy("请让 Agent 检查素材、字体和配音时长；修改脚本后保存新修订，或修复本机依赖后重试。", "Ask your Agent to check sources, fonts and narration timing. Save a new revision for story changes, or repair the local dependencies and retry.")}</p> : null}
+        <details><summary>{copy("来源与检查", "Sources and checks")}</summary><ul>{selected.shots.map((shot, i) => <li key={i}>{shot.title} — {shot.boundary}<br /><small>{shot.source_ref}</small></li>)}</ul>
+          <p>{copy("本机私有作品。编码通过不代表创意质量、理解效果或发布许可；请观看并试听。", "Private local work. Encoding does not establish creative quality, audience understanding or publication approval. Watch and listen before sharing.")}</p></details>
+      </div></div> : null}
+  </section>;
+}
diff --git a/apps/presentation/dashboard/src/features/personal-workspace/goal-capability-settings.tsx b/apps/presentation/dashboard/src/features/personal-workspace/goal-capability-settings.tsx
index 9faf3b3bfd..29e578440d 100644
--- a/apps/presentation/dashboard/src/features/personal-workspace/goal-capability-settings.tsx
+++ b/apps/presentation/dashboard/src/features/personal-workspace/goal-capability-settings.tsx
@@ -18,6 +18,7 @@ import { localizeCapability, localizedCapabilityFieldCopy } from "./capability-l
 import { orderCapabilitiesForPresentation, canEditCapability, CapabilityCatalogNavigation, CapabilityConfigurationSummary, CapabilityDetailHeader, CapabilityEditorStatus, CapabilityConfigurationHelp } from "./capability-workbench";
 import { GoalAutoNotifyToggle } from "./notification-settings-panel";
 import { ContentReferenceWorkbench } from "./content-reference-workbench";
+import {ContentMediaWorkbench} from "./content-media-workbench";
 import { DecisionContextWorkbench } from "./decision-context-workbench";
 import { rewardMemoryBindingStatus, rewardMemoryScopeDraft, rewardMemoryWriteValue } from "./reward-memory-settings";
 import {isMemoryCapability, memorySettingsTitle, MemorySettingsHeader} from "./memory-settings";
@@ -322,18 +323,20 @@ function CapabilityCatalog({ callbacks, catalog, goalId, loading, notification,
       <article aria-label={memorySelected ? memorySettingsTitle(locale) : localizedSelected.display_name} className="personal-capability-detail" tabIndex={0}>
         {memorySelected ? <MemorySettingsHeader capabilities={orderedCapabilities} locale={locale}
           selectedId={selected.capability_id} onSelect={setSelectedCapabilityId}
-          onRefresh={() => void onApplied()} disabled={editorBusy} /> : <CapabilityDetailHeader capability={selected} locale={locale}
+          onRefresh={() => void onApplied()} disabled={editorBusy} /> : selected.capability_id === "content_ops"
+          ? <header><div><h2>{localizedSelected.display_name}</h2><p>{localizedSelected.description}</p></div></header>
+          : <CapabilityDetailHeader capability={selected} locale={locale}
           source={localizedSelected.effective_configuration?.source} />}
         {memorySelected && orderedCapabilities.some(item => item.capability_id === "decision_context") ? <section
           aria-labelledby="memory-purpose-decision_context" hidden={selected.capability_id !== "decision_context"}
           id="memory-panel-decision_context" role="tabpanel" tabIndex={0}>
           <DecisionContextWorkbench key={goalId} goalId={goalId} active={selected.capability_id === "decision_context"} />
         </section> : null}
-        <section hidden={selected.capability_id === "decision_context"}
+        <section className={selected.capability_id === "content_ops" ? "content-production-panel" : undefined} hidden={selected.capability_id === "decision_context"}
           id={memorySelected && selected.capability_id !== "decision_context" ? `memory-panel-${selected.capability_id}` : undefined}
           aria-labelledby={memorySelected && selected.capability_id !== "decision_context" ? `memory-purpose-${selected.capability_id}` : undefined}
           role={memorySelected && selected.capability_id !== "decision_context" ? "tabpanel" : undefined}>
-        {localizedSelected.capability_id === "content_ops" ? <ContentReferenceWorkbench key={goalId} /> : <CapabilityEditorStatus available={editorAvailable} t={t}
+        {localizedSelected.capability_id === "content_ops" ? <><ContentMediaWorkbench key={goalId} goalId={goalId} /><details><summary>{locale === "zh-CN" ? "来源风格素材" : "Source style references"}</summary><ContentReferenceWorkbench key={goalId} /></details></> : <CapabilityEditorStatus available={editorAvailable} t={t}
           description={readOnlyReason} />}
 
         {selected.capability_id === "progress_review" && selected.observation ? <section className="personal-capability-observation" aria-label={locale === "zh-CN" ? "审查证据读回" : "Review evidence readback"}>
diff --git a/apps/presentation/dashboard/src/features/personal-workspace/memory-settings.tsx b/apps/presentation/dashboard/src/features/personal-workspace/memory-settings.tsx
index 887274fb4b..8bd92680b7 100644
--- a/apps/presentation/dashboard/src/features/personal-workspace/memory-settings.tsx
+++ b/apps/presentation/dashboard/src/features/personal-workspace/memory-settings.tsx
@@ -4,7 +4,7 @@ import type {WorkspaceLocale} from "./i18n";
 type Capability = CapabilityConfigurationCatalog["capabilities"][number];
 
 // Local navigation only. Each purpose retains its native capability/configuration owner.
-const purposes = ["decision_context", "reward_memory", "content_ops"] as const;
+const purposes = ["decision_context", "reward_memory"] as const;
 export function isMemoryCapability(id: string) {return purposes.some(purpose => purpose === id);}
 export function memorySettingsTitle(locale: WorkspaceLocale) {return locale === "zh-CN" ? "记忆与资料" : "Memory & sources";}
 export function memoryCapabilities(capabilities: readonly Capability[]) {
@@ -31,8 +31,6 @@ export function MemorySettingsHeader({capabilities, locale, onSelect, selectedId
       effect: cn ? "按问题查找已有材料。不会保存配置或开启 Agent 的自动记忆。" : "Find existing material for a question. This does not save configuration or enable automatic Agent memory."},
     reward_memory: {name: cn ? "经验学习" : "Learn from outcomes", mode: cn ? "持久配置 · 实验功能" : "Saved configuration · experimental",
       effect: cn ? "为指定 Agent 配置经验复用；旧版共享绑定单独管理。配置、自动召回和写回的实际接入分别验证。" : "Configure experience reuse for a named Agent, or manage a legacy shared binding separately. Configuration, automatic recall and writeback each require their own verification."},
-    content_ops: {name: cn ? "素材与风格" : "Reference styles", mode: cn ? "只读素材目录" : "Read-only reference catalog",
-      effect: cn ? "查找参考素材的表达和结构，保留来源署名；与事实证据、Agent 经验分开使用。" : "Find source-attributed writing styles and structures, separately from factual evidence and Agent experience."},
   };
   const available = memoryCapabilities(capabilities);
   const selected = purposes.find(id => id === selectedId);
diff --git a/docs/reference/protocols/README.md b/docs/reference/protocols/README.md
index c185638245..28f9e8c49c 100644
--- a/docs/reference/protocols/README.md
+++ b/docs/reference/protocols/README.md
@@ -84,6 +84,7 @@ scanning a chronological list.
 - [`content_ops_item_v0`](content-ops-item-lifecycle-v0.md): provider-neutral content item lifecycle v0
 - [`content_ops_queue_projection_v0`](content-ops-queue-v0.md): read-only managed content queue projection v0
 - [`content_ops_layout_plan_v0`](content-ops-layout-v0.md): typed content layout plan, template library, and acceptance check v0
+- [`content_ops_media_plan_v0`](content-ops-media-v0.md): private source-bound composition, optional rendering and packaged result readback
 
 ## Quality, Review, And Release
 
diff --git a/docs/reference/protocols/content-ops-media-v0.md b/docs/reference/protocols/content-ops-media-v0.md
new file mode 100644
index 0000000000..259cfbcba4
--- /dev/null
+++ b/docs/reference/protocols/content-ops-media-v0.md
@@ -0,0 +1,117 @@
+# Private content composition v0
+
+The existing `content-ops` capability owns video preparation, render attempts
+and result readback. The TypeScript owner is
+`loopx/control_plane/capabilities/content_media.ts`. Python handles private
+files and transport; the optional `loopx-media` extension performs specialized
+image, audio and video computation. This is a local composition slice, not a
+new generic capability or a replacement publication lifecycle.
+
+The active callers are the Agent-facing CLI and the Goal's packaged **Content
+production** workbench. A prepared brief is shared between them. The Agent
+absorbs source discovery, identifiers, hashes and timing. The owner selects a
+prepared composition, starts/cancels its render and reads the result in place;
+there is no browser source-directory or JSON-entry step. Lark can convey the
+request to an Agent but does not gain an independent renderer or upload action.
+
+## Plan and source scope
+
+`content_ops_media_plan_v0` contains:
+
+| Field | Meaning |
+| --- | --- |
+| `title`, `width`, `height`, `fps` | Name and bounded output geometry/clock; dimensions must be even. |
+| `layout_template_id` | Existing content-ops layout template, default `monochrome-editorial`; style tokens enter the digest. |
+| `shots` | Ordered distinct `id`, `kind`, frame-aligned `seconds`, `title`, optional `body`, `source_ref`, explicit `boundary`. |
+| `assets` | Distinct id, relative `path`, exact `sha256`, `image`/`video`/`audio`, `source_ref` and `local_private`/`public_safe` source classification. |
+| `captions` | Ordered nonoverlapping `start`, `end`, `text`, `language` cues inside the composition. One sequential caption track is emitted. |
+| `narration` | Explicit `silent`, `supplied` with audio `asset_id`, or `system_speech` with installed `voice` and optional words-per-minute. |
+
+Shots are `title`, `diagram` (two to five `nodes`) or `excerpt` (image/video
+`asset_id` and optional `start_seconds`). These are composition-local rendering
+choices. They do not extend Goal/Todo state. Likewise prepared/rendering/ready/
+failed/cancelled/interrupted describe private render attempts, never published
+content or Agent liveness. An old saved running attempt is shown as interrupted
+after its bounded execution window; a read does not restart it.
+
+Preparation takes an explicit local source directory. Absolute paths,
+traversal, symlinks and wrong source digests are refused. The prepared record
+contains immutable private source copies; editing the original afterward does
+not change an admitted composition. No URL is fetched. A `source_ref` records
+provenance supplied by the caller; a `public_safe` label does not prove rights,
+truth, current product behavior or public publication permission.
+
+The canonical digest binds story, sources, source boundaries, layout tokens,
+geometry, timing, captions and narration. Canonical plans can be revalidated
+without changing that digest. A changed plan requires the expected revision
+and invalidates old content approval. Existing layout tokens are reused;
+static page-density rules do not certify a timed movie or its learning effect.
+
+## Execution and readback
+
+```sh
+loopx content-ops media prepare --goal-id example-goal \
+  --plan-json examples/content-ops-media-brief.json --source-directory . \
+  --format json
+loopx content-ops media render --goal-id example-goal \
+  --composition-id COMPOSITION_FROM_PREPARE --expected-revision 1 --format json
+loopx content-ops media inspect --goal-id example-goal \
+  --composition-id COMPOSITION_FROM_PREPARE --format json
+```
+
+`list` discovers the latest 100 private compositions; `cancel` requires the
+current composition and revision. An already running render is returned without
+a second effect. Cancel is a request until the worker settles. After a failed,
+cancelled, interrupted or damaged attempt, explicit render can retry. Intact
+completed bytes are reused. A changed story uses `prepare --composition-id …
+--expected-revision …` first. The render lock spans the actual effect, in
+addition to revision-bound record writes.
+
+The existing extension lifecycle owns installation, enablement, doctor,
+entrypoint identity and the `content_media_write` permission. Loading the page
+or preparing a plan never installs a provider. Disabled/unavailable extensions
+block new effects while preserving prepared sources and verified downloads.
+See [installation, dependency and disable instructions](../../../packages/loopx-media/README.md).
+
+The private `content_ops_media_renderer_v0` envelope carries the validated plan,
+layout tokens, digest, frame count, immutable snapshots, exclusive attempt
+directory and attempt-scoped cancel flag. Only a verified installed extension
+receives those paths. The result projection accepts fixed output names and
+exact SHA256/byte counts; paths and undeclared provider fields are discarded.
+The core reads every actual file before committing `ready`. Required outputs
+are `video.mp4`, `poster.png`, `captions.vtt`, `captions.srt` and `transcript.txt`,
+plus `narration.wav` for audible modes. Full decode must match the admitted
+timeline, geometry and narration mode. Audio checks report peak and clipped
+PCM samples; subjective listening remains untested.
+
+Both plan and output bytes bind the existing `content_ops_item_v0`. Producing
+or re-encoding a movie revises its content digest and clears any approval and
+delivery intent. This renderer neither approves nor posts. Publication and
+its account/channel/timing/readback remain with the
+[existing item lifecycle](content-ops-item-lifecycle-v0.md).
+
+## HTTP boundary and failure behavior
+
+The loopback Chat server exposes `POST /api/chat/content-media` for list,
+inspect, render and cancel. Render/cancel use the current revision; the server
+binds the registered Goal/source route and rejects a different selected Goal,
+foreign origin or filesystem fields. Rendering runs in a bounded background
+worker so the page remains responsive. Polling occurs only while a render is
+pending and stops after a terminal readback.
+
+`GET /api/chat/content-media/file` serves only fixed verified files from that
+composition, with byte ranges for playback, no-store and same-origin resource
+policy. It refuses escaping filenames, non-ready and damaged artifacts; it
+does not serve the private manifest or source files. Browser error projections
+do not include provider stderr or private paths.
+
+Missing provider, changed source, stale revision, text/glyph overflow, short
+footage, invalid narration timing, cancellation, stopped host and damaged bytes
+remain distinguishable from success. Repair the source/brief as a new revision
+or repair the existing extension and retry. No failure creates publication
+authority, fills missing footage, infers a creative pass or changes a Goal.
+
+Mechanical rendering, creative quality, audience understanding and operations
+impact have separate evidence. Future Blender, generated media and interactive
+learning providers should reuse the nearest content owner and comparison
+method; they are not silently activated by this protocol.
diff --git a/docs/reference/protocols/content-ops-reference-v0.md b/docs/reference/protocols/content-ops-reference-v0.md
index 14b25fcee7..d84cf8ff49 100644
--- a/docs/reference/protocols/content-ops-reference-v0.md
+++ b/docs/reference/protocols/content-ops-reference-v0.md
@@ -73,7 +73,7 @@ unknown reuse boundary, version mismatch or empty facts. It never substitutes
 the source's assertions for facts about the caller's subject.
 
 Discover this route through the existing capability catalog. In the packaged
-frontend, open **Settings → Capabilities → a Goal → Reference styles**.
+frontend, open **Settings → Capabilities → a Goal → Content production → Source style references**.
 Import an authorized catalog, filter references, choose a structure and supply
 your own facts to prepare an attributed outline. Capture/correction is an
 optional request-JSON section. Downloads are new private review artifacts;
diff --git a/examples/content-ops-media-brief.json b/examples/content-ops-media-brief.json
new file mode 100644
index 0000000000..4646e8cd45
--- /dev/null
+++ b/examples/content-ops-media-brief.json
@@ -0,0 +1,17 @@
+{
+  "schema_version": "content_ops_media_plan_v0",
+  "title": "Return the evidence",
+  "width": 1280,
+  "height": 720,
+  "fps": 24,
+  "shots": [
+    {"id": "opening", "kind": "title", "seconds": 5, "title": "A result needs a return route.", "body": "Keep the original request visible.", "source_ref": "synthetic:handoff", "boundary": "Illustrated workflow; no live execution"},
+    {"id": "handoff", "kind": "diagram", "seconds": 7, "title": "Make the handoff complete.", "nodes": ["Intent", "Owner", "Work", "Evidence"], "source_ref": "synthetic:handoff", "boundary": "Mechanism illustration; no performance claim"}
+  ],
+  "assets": [],
+  "captions": [
+    {"start": 0, "end": 5, "text": "A result needs a return route.", "language": "en"},
+    {"start": 5, "end": 12, "text": "Keep context and acceptance with the work.", "language": "en"}
+  ],
+  "narration": {"mode": "silent"}
+}
diff --git a/loopx/capabilities/content_ops/README.md b/loopx/capabilities/content_ops/README.md
index f895d5a661..dd0c3d32e4 100644
--- a/loopx/capabilities/content_ops/README.md
+++ b/loopx/capabilities/content_ops/README.md
@@ -4,9 +4,9 @@ The content-ops capability is the product path for creator/operator workflows:
 public handles, private connector gates, source items, angle candidates, draft
 states, feedback signals, and publish gates.
 
-Current implementation remains preview-level. It is useful because it gives real
-connector and review surfaces a safe packet format before raw material is copied
-or published.
+Connector packets remain preview-level. Local item lifecycle, reference
+preparation and optional video composition have their own delivery boundaries;
+none grants publication authority.
 
 The capability also ships a provider-neutral item lifecycle for real local
 operations queues. It preserves stable item identity, revision-bound approval,
@@ -29,11 +29,20 @@ or role-incomplete page sets. See
 
 ## Implemented Surface
 
+`loopx content-ops media` prepares source-bound private compositions and renders
+them through the optional local `loopx-media` extension. The packaged
+**Settings → Capabilities → a Goal → Content production** workbench renders,
+cancels and reads the same compositions, video, captions, transcript and source
+checks. It reuses existing layout tokens and content-item revision/approval,
+while keeping heavy image/audio/video computation in the optional distribution.
+See the [composition contract](../../../docs/reference/protocols/content-ops-media-v0.md)
+and [renderer installation and recovery](../../../packages/loopx-media/README.md).
+
 `loopx content-ops reference` reads an existing private source/style catalog,
 prepares version-checked capture/correction artifacts, retrieves topic/structure
 references, and prepares outlines with original credit and reuse conditions.
-The same TypeScript owner runs in the packaged **Capabilities → Goal → Reference
-styles** workbench. Imports stay in browser page memory; downloads are private
+The same TypeScript owner runs in the packaged **Content production → Source
+style references** workbench. Imports stay in browser page memory; downloads are private
 review artifacts. This preview does not write the original catalog or activate
 a source. Inventory reuses Material Lifecycle, while managed apply/rollback
 still requires that owner's qualified source provider. See
diff --git a/loopx/capabilities/content_ops/cli.py b/loopx/capabilities/content_ops/cli.py
index 0d99f0126f..1d14a8dcad 100644
--- a/loopx/capabilities/content_ops/cli.py
+++ b/loopx/capabilities/content_ops/cli.py
@@ -27,6 +27,7 @@
     render_layout_packet_markdown,
 )
 from .reference import content_reference_operation, inspect_reference_materials, write_reference_artifact
+from .media_cli import handle_media_command, register_media_commands
 from .surface import (
     build_content_ops_chatview_report_packet,
     build_content_ops_exploration_plan_packet,
@@ -140,6 +141,7 @@ def register_content_ops_commands(
         dest="content_ops_command",
         required=True,
     )
+    register_media_commands(content_ops_sub, add_subcommand_format)
     reference_parser = content_ops_sub.add_parser(
         "reference", help="Search, capture or prepare an attributed outline from a caller-owned private catalog.",
     )
@@ -563,6 +565,9 @@ def handle_content_ops_command(
         issue_fix_result = handle_content_ops_issue_fix_command(args)
         if issue_fix_result is not None:
             payload, renderer = issue_fix_result
+        elif args.content_ops_command == "media":
+            payload = handle_media_command(args)
+            renderer = lambda value: json.dumps(value, ensure_ascii=False, indent=2) + "\n"
         elif args.content_ops_command == "reference":
             if args.operation == "inventory":
                 if not args.goal_id or not args.store_id or not args.observed_at or args.library_json == "-":
diff --git a/loopx/capabilities/content_ops/media.py b/loopx/capabilities/content_ops/media.py
new file mode 100644
index 0000000000..d5463e252c
--- /dev/null
+++ b/loopx/capabilities/content_ops/media.py
@@ -0,0 +1,268 @@
+"""Private composition I/O and optional renderer execution.
+
+The shared TS owner validates plans and render transitions. Content publication
+continues to use item_lifecycle; an encoded movie never grants publication.
+"""
+from __future__ import annotations
+
+from datetime import datetime, timezone
+import hashlib
+import json
+import os
+from pathlib import Path
+import re
+import stat
+import threading
+from typing import Any
+from uuid import uuid4
+
+from ...control_plane.effect_runtime import effect_runtime_result
+from ...control_plane.projects.registry_codec import load_registry
+from ...extensions.runtime import default_extension_state_file, execute_extension_runtime_binding, resolve_optional_capability_binding
+from ...file_lock import exclusive_file_lock, write_json_atomic
+from ...registry import find_registry_goal
+from .item_lifecycle import apply_content_ops_item_event, build_content_ops_item
+
+PROTOCOL = "content_ops_media_renderer_v0"
+RESULT_FILES = {"video.mp4", "poster.png", "captions.vtt", "captions.srt", "transcript.txt", "narration.wav", "manifest.json"}
+MAX_ASSET_BYTES = 64 * 1024 * 1024
+
+
+def now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _owner(operation: str, request: dict) -> dict:
+    return effect_runtime_result(f"content_media.{operation}", request)
+
+
+def _safe_path(root: Path, relative: str) -> Path:
+    if root.is_symlink(): raise ValueError("Composition directory must not be a symlink")
+    parts = Path(relative).parts
+    if not parts or Path(relative).is_absolute() or any(p in {"..", "."} for p in parts):
+        raise ValueError("File is outside the selected composition scope")
+    current = root
+    for part in parts:
+        current /= part
+        if current.is_symlink():
+            raise ValueError("Symlink sources and outputs are not supported")
+    if not current.resolve().is_relative_to(root.resolve()):
+        raise ValueError("File is outside the selected composition scope")
+    return current
+
+
+def _read(path: Path) -> dict:
+    if path.is_symlink() or path.stat().st_size > 1024 * 1024:
+        raise ValueError("Invalid saved composition")
+    with path.open(encoding="utf-8") as source:
+        value = json.load(source)
+    if not isinstance(value, dict):
+        raise ValueError("Invalid saved composition")
+    return value
+
+
+def _save(path: Path, value: dict) -> None:
+    write_json_atomic(path, value, mode=0o600, directory_mode=0o700, fsync_directory=True)
+
+
+def _sha(path: Path) -> str:
+    with path.open("rb") as source:
+        return hashlib.file_digest(source, "sha256").hexdigest()
+
+
+class MediaWorkspace:
+    """Goal-scoped owner-local files. The browser never supplies filesystem paths."""
+
+    def __init__(self, *, registry_path: Path, goal_id: str, runtime_root: Path):
+        goal = find_registry_goal(load_registry(registry_path), goal_id)
+        if goal is None or not isinstance(goal.get("repo"), str):
+            raise ValueError("Select a registered local Goal")
+        self.project = Path(goal["repo"]).expanduser().resolve(strict=True)
+        scope = hashlib.sha256(goal_id.encode()).hexdigest()[:24]
+        self.root = _safe_path(self.project, f".local/content-media/{scope}")
+        self.runtime_root = runtime_root
+
+    def binding(self):
+        return resolve_optional_capability_binding(state_file=default_extension_state_file(self.runtime_root),
+            capability_id="content-ops", protocol=PROTOCOL, permission="content_media_write", extension_id="loopx-media")
+
+    def _bundle(self, composition_id: str) -> Path:
+        if not isinstance(composition_id, str) or not re.fullmatch(r"media_[a-f0-9]{24}", composition_id):
+            raise ValueError("Invalid composition reference")
+        return _safe_path(self.root, composition_id)
+
+    def _record(self, composition_id: str) -> dict:
+        return _read(_safe_path(self._bundle(composition_id), "record.json"))
+
+    def prepare(self, plan: dict, *, source_directory: Path, composition_id: str | None = None, expected_revision: int | None = None) -> dict:
+        validated = _owner("plan", {"plan": plan})
+        composition_id = composition_id or f"media_{uuid4().hex[:24]}"
+        bundle = self._bundle(composition_id)
+        bundle.mkdir(mode=0o700, parents=True, exist_ok=True)
+        with exclusive_file_lock(bundle / "record.json", operation="content-media-prepare"):
+            previous = self._record(composition_id) if (bundle / "record.json").exists() else None
+            if previous and (expected_revision != previous["revision"] or previous["status"] == "rendering"):
+                raise ValueError("Inspect the current revision before changing this composition")
+            if previous and previous["plan_digest"] == validated["plan_digest"]:
+                return self.inspect(composition_id)
+            source_root = source_directory.expanduser().resolve(strict=True)
+            if not source_root.is_dir():
+                raise ValueError("Choose an explicit source directory")
+            snapshots, total = {}, 0
+            inputs = _safe_path(bundle, "sources")
+            inputs.mkdir(mode=0o700, exist_ok=True)
+            for asset in validated["plan"]["assets"]:
+                original = _safe_path(source_root, asset["path"])
+                descriptor = os.open(original, os.O_RDONLY | getattr(os, "O_NOFOLLOW", 0))
+                with os.fdopen(descriptor, "rb") as source:
+                    info = os.fstat(source.fileno())
+                    total += info.st_size
+                    if not stat.S_ISREG(info.st_mode) or info.st_size > MAX_ASSET_BYTES or total > 128 * 1024 * 1024:
+                        raise ValueError("Sources exceed the local composition budget")
+                    content = source.read(MAX_ASSET_BYTES + 1)
+                    if len(content) != info.st_size or hashlib.sha256(content).hexdigest() != asset["sha256"]:
+                        raise ValueError("Source bytes changed; check the source digest before preparing")
+                path = _safe_path(inputs, asset["sha256"])
+                if path.exists():
+                    if _sha(path) != asset["sha256"]: raise ValueError("Source snapshot is damaged")
+                else:
+                    fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
+                    with os.fdopen(fd, "wb") as output: output.write(content)
+                snapshots[asset["id"]] = str(path)
+            item = previous["item"] if previous else build_content_ops_item(
+                item_id=composition_id, item_kind="post", channel="local-media", content_digest=validated["plan_digest"],
+                content_ref=f"content-media:{composition_id}", source_refs=[f"source:{a['sha256']}" for a in validated["plan"]["assets"]], created_at=now())
+            if previous:
+                item = apply_content_ops_item_event(item, {"event_id": f"revise_{uuid4().hex}", "action": "revise",
+                    "expected_state": item["state"], "expected_revision": item["revision"], "occurred_at": now(),
+                    "payload": {"content_digest": validated["plan_digest"], "content_ref": f"content-media:{composition_id}",
+                                "source_refs": [f"source:{a['sha256']}" for a in validated["plan"]["assets"]]}})["item"]
+            record = {**validated, "composition_id": composition_id, "revision": previous["revision"] + 1 if previous else 1, "status": "prepared",
+                      "item": item, "sources": snapshots, "updated_at": now(), "attempt": None, "result": None,
+                      "previous_result": previous.get("result") if previous else None}
+            _save(bundle / "record.json", record)
+        return self.inspect(composition_id)
+
+    def inspect(self, composition_id: str) -> dict:
+        record = self._record(composition_id)
+        # A stopped host is recoverable on explicit render, never restarted by GET.
+        status = record["status"]
+        if status == "rendering":
+            age = (datetime.now(timezone.utc) - datetime.fromisoformat(record["updated_at"])).total_seconds()
+            if age > 150: status = "interrupted"
+        result = record.get("result")
+        if result:
+            for name, entry in result["files"].items():
+                path = _safe_path(self._bundle(composition_id), f"{record['attempt']}/{name}")
+                if not path.is_file() or _sha(path) != entry["sha256"]:
+                    status = "damaged"; break
+        return {"ok": True, "composition_id": composition_id, "revision": record["revision"], "status": status,
+                "title": record["plan"]["title"], "duration_seconds": record["duration_seconds"],
+                "plan_digest": record["plan_digest"], "shots": [{k: shot[k] for k in ("title", "seconds", "kind", "boundary", "source_ref")} for shot in record["plan"]["shots"]],
+                "updated_at": record["updated_at"], "result": result, "item_state": record["item"]["state"],
+                "error_code": record.get("error_code"), "provider": self.binding().public_readiness(),
+                "visibility": "local_private", "publish_authorized": False}
+
+    def list(self) -> dict:
+        paths = sorted(self.root.glob("media_*/record.json"), key=lambda path: path.stat().st_mtime, reverse=True) if self.root.exists() else []
+        if len(paths) > 100: paths = paths[:100]
+        return {"ok": True, "compositions": [self.inspect(path.parent.name) for path in paths],
+                "provider": self.binding().public_readiness(), "visibility": "local_private"}
+
+    def _transition(self, record: dict, action: str) -> dict:
+        return _owner("transition", {"state": record, "action": action, "expected_revision": record["revision"], "observed_at": now()})["state"]
+
+    def render(self, composition_id: str, *, expected_revision: int, background: bool = False) -> dict:
+        bundle = self._bundle(composition_id)
+        # The run lock spans the real provider effect; a second process cannot
+        # steal a timed-out UI request's writer while that effect is still alive.
+        with exclusive_file_lock(bundle / "record.json", operation="content-media-start"):
+            record = self._record(composition_id)
+            if record["revision"] != expected_revision:
+                raise ValueError("Composition revision changed; inspect before rendering")
+            binding = self.binding()
+            if binding.binding is None:
+                return {"ok": False, "status": "provider_unavailable", "provider": binding.public_readiness()}
+            if record["status"] == "ready" and self.inspect(composition_id)["status"] == "ready":
+                return self.inspect(composition_id)
+            if record["status"] == "rendering":
+                if self.inspect(composition_id)["status"] != "interrupted":
+                    return self.inspect(composition_id)
+                record = self._transition(record, "interrupt")
+            # Validate persisted data again before every effect, not only import.
+            checked = _owner("plan", {"plan": record["plan"]})
+            if checked["plan_digest"] != record["plan_digest"]:
+                raise ValueError("Composition bytes changed; prepare a new revision")
+            record = self._transition(record, "start")
+            record["attempt"] = f"attempt_{uuid4().hex}"
+            record["result"] = None
+            record["error_code"] = None
+            _save(bundle / "record.json", record)
+        if background:
+            threading.Thread(target=self._execute, args=(composition_id, record["attempt"]), daemon=True).start()
+            return self.inspect(composition_id)
+        self._execute(composition_id, record["attempt"])
+        return self.inspect(composition_id)
+
+    def _execute(self, composition_id: str, attempt: str) -> None:
+        bundle = self._bundle(composition_id)
+        with exclusive_file_lock(bundle / "render", operation="content-media-render", timeout_seconds=1):
+            record = self._record(composition_id)
+            if record["attempt"] != attempt or record["status"] != "rendering": return
+            cancel = _safe_path(bundle, f"{attempt}.cancel")
+            try:
+                binding = self.binding()
+                if binding.binding is None: raise ValueError("Provider unavailable")
+                checked = _owner("plan", {"plan": record["plan"]})
+                result = execute_extension_runtime_binding(binding.binding, request={"protocol": PROTOCOL,
+                    "plan": record["plan"], "layout_style": checked["layout_style"],
+                    "plan_digest": record["plan_digest"], "frame_count": record["frame_count"],
+                    "sources": record["sources"], "attempt_directory": str(_safe_path(bundle, attempt)), "cancel_file": str(cancel)})
+                result = _owner("result", {"result": result, "plan_digest": record["plan_digest"],
+                    "frame_count": record["frame_count"], "narration_mode": record["plan"]["narration"]["mode"],
+                    **{k: record["plan"][k] for k in ("width", "height", "fps")}})
+                required = {"video.mp4", "poster.png", "captions.vtt", "captions.srt", "transcript.txt"}
+                if not required <= set(result["files"]) or set(result["files"]) - RESULT_FILES:
+                    raise ValueError("Renderer output is incomplete")
+                for name, entry in result["files"].items():
+                    path = _safe_path(bundle, f"{attempt}/{name}")
+                    if not path.is_file() or path.stat().st_size != entry["bytes"] or _sha(path) != entry["sha256"]:
+                        raise ValueError("Renderer output readback failed")
+                if result["qa"]["frames"] != record["frame_count"] or result["qa"]["full_decode"] != "passed":
+                    raise ValueError("Renderer did not qualify the full timeline")
+                record["result"] = result
+                action = "cancel" if cancel.exists() else "success"
+                if action == "success":
+                    # Approval is bound to the actual output bytes as well as
+                    # the plan. A re-encode cannot inherit an earlier approval.
+                    artifact_digest = "sha256:" + hashlib.sha256(json.dumps(
+                        {"plan_digest": record["plan_digest"], "files": result["files"]}, sort_keys=True).encode()).hexdigest()
+                    item = record["item"]
+                    record["item"] = apply_content_ops_item_event(item, {"event_id": f"render_{attempt}", "action": "revise",
+                        "expected_state": item["state"], "expected_revision": item["revision"], "occurred_at": now(),
+                        "payload": {"content_digest": artifact_digest, "content_ref": f"content-media:{composition_id}"}})["item"]
+            except (OSError, ValueError, RuntimeError, KeyError, TypeError):
+                action = "cancel" if cancel.exists() else "failure"
+                record["result"] = None
+                record["error_code"] = "cancelled" if action == "cancel" else "render_failed"
+            with exclusive_file_lock(bundle / "record.json", operation="content-media-finish"):
+                current = self._record(composition_id)
+                if current["attempt"] == attempt and current["revision"] == record["revision"]:
+                    _save(bundle / "record.json", self._transition(record, action))
+
+    def cancel(self, composition_id: str, *, expected_revision: int) -> dict:
+        bundle, record = self._bundle(composition_id), self._record(composition_id)
+        if record["revision"] != expected_revision or record["status"] != "rendering":
+            raise ValueError("No matching render is running")
+        path = _safe_path(bundle, f"{record['attempt']}.cancel")
+        path.touch(mode=0o600, exist_ok=True)
+        return {"ok": True, "status": "cancellation_requested", "composition_id": composition_id}
+
+    def file(self, composition_id: str, name: str) -> Path:
+        if name not in RESULT_FILES: raise ValueError("Unsupported result file")
+        record = self._record(composition_id)
+        if record["status"] != "ready" or self.inspect(composition_id)["status"] != "ready":
+            raise ValueError("A verified result is not available")
+        if name == "manifest.json": raise ValueError("Use the path-free result projection")
+        if name not in record["result"]["files"]: raise ValueError("Result file is not available")
+        return _safe_path(self._bundle(composition_id), f"{record['attempt']}/{name}")
diff --git a/loopx/capabilities/content_ops/media_cli.py b/loopx/capabilities/content_ops/media_cli.py
new file mode 100644
index 0000000000..83c8c715d9
--- /dev/null
+++ b/loopx/capabilities/content_ops/media_cli.py
@@ -0,0 +1,38 @@
+"""CLI transport for the existing content-ops composition owner."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from .media import MediaWorkspace
+from ...paths import default_registry_path, effective_runtime_root
+
+
+def register_media_commands(subparsers, add_format) -> None:
+    parser = subparsers.add_parser("media", help="Prepare and render a private, source-bound local video.")
+    parser.add_argument("operation", choices=("prepare", "render", "inspect", "list", "cancel"))
+    parser.add_argument("--goal-id", required=True)
+    parser.add_argument("--plan-json", help="Agent-prepared composition plan; at most 256 KiB.")
+    parser.add_argument("--source-directory", help="Explicit read scope for digest-bound local assets.")
+    parser.add_argument("--composition-id")
+    parser.add_argument("--expected-revision", type=int)
+    add_format(parser)
+
+
+def handle_media_command(args) -> dict:
+    registry = Path(args.registry) if args.registry else default_registry_path()
+    workspace = MediaWorkspace(registry_path=registry, goal_id=args.goal_id,
+                               runtime_root=effective_runtime_root(registry, args.runtime_root))
+    if args.operation == "list": return workspace.list()
+    if args.operation == "prepare":
+        if not args.plan_json or not args.source_directory:
+            raise ValueError("prepare requires --plan-json and --source-directory")
+        path = Path(args.plan_json).expanduser()
+        if path.stat().st_size > 256 * 1024: raise ValueError("Composition plan exceeds 256 KiB")
+        return workspace.prepare(json.loads(path.read_text(encoding="utf-8")), source_directory=Path(args.source_directory),
+                                 composition_id=args.composition_id, expected_revision=args.expected_revision)
+    if not args.composition_id: raise ValueError("Select an existing composition")
+    if args.operation == "inspect": return workspace.inspect(args.composition_id)
+    if args.expected_revision is None: raise ValueError("Read the current --expected-revision first")
+    if args.operation == "render": return workspace.render(args.composition_id, expected_revision=args.expected_revision)
+    return workspace.cancel(args.composition_id, expected_revision=args.expected_revision)
diff --git a/loopx/capabilities/content_ops/reference.py b/loopx/capabilities/content_ops/reference.py
index b381f77b1d..3a25ebcef2 100644
--- a/loopx/capabilities/content_ops/reference.py
+++ b/loopx/capabilities/content_ops/reference.py
@@ -60,7 +60,7 @@ def write_reference_artifact(path: Path, payload: Mapping[str, Any]) -> None:
 
 def reference_configuration_descriptor() -> dict[str, Any]:
     """Discover a native operation in the existing workbench, without a switch."""
-    return {"feature_id": "content_ops", "display_name": "Content references",
+    return {"feature_id": "content_ops", "display_name": "Content production",
             "availability": "local_artifact_preview",
-            "effect": "Import an existing local catalog, retrieve styles and prepare an attributed outline. Source/store writes remain unavailable.",
+            "effect": "Prepare attributed outlines and source-bound local videos. Video rendering requires the optional local extension; source catalog writes and publishing remain separate.",
             "documentation": {"path": "loopx/capabilities/content_ops/README.md"}}
diff --git a/loopx/control_plane/capabilities/content_media.ts b/loopx/control_plane/capabilities/content_media.ts
new file mode 100644
index 0000000000..7b3364f7da
--- /dev/null
+++ b/loopx/control_plane/capabilities/content_media.ts
@@ -0,0 +1,157 @@
+/** Content-ops composition semantics. Rendering is an optional, local-only effect.
+ * These render states are local to a composition, never publication approvals.
+ */
+import {createHash} from "node:crypto";
+import {EffectRuntimeRequestError} from "../effect_runtime_errors.ts";
+import layouts from "../../capabilities/content_ops/templates/layout-catalog-v0.json" with {type: "json"};
+
+export const MEDIA_PLAN_SCHEMA = "content_ops_media_plan_v0";
+export const MEDIA_PROTOCOL = "content_ops_media_renderer_v0";
+type ObjectValue = Record<string, unknown>;
+function fail(message: string): never {throw new EffectRuntimeRequestError(message);}
+function object(value: unknown): ObjectValue {
+  if (!value || typeof value !== "object" || Array.isArray(value)) fail("Expected an object");
+  return value as ObjectValue;
+}
+function fields(value: ObjectValue, allowed: string[]) {
+  if (Object.keys(value).some(key => !allowed.includes(key))) fail("Unsupported composition fields");
+}
+function text(value: unknown, max = 500): string {
+  if (typeof value !== "string" || !value.trim() || value.length > max || /[\x00-\x08\x0b-\x1f]/.test(value)) fail("Invalid composition text");
+  return value.trim();
+}
+function token(value: unknown): string {
+  const result = text(value, 80);
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(result)) fail("Invalid composition reference");
+  return result;
+}
+function number(value: unknown, min: number, max: number, integer = false): number {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < min || value > max || (integer && !Number.isInteger(value))) fail("Composition timing or dimensions are outside the supported range");
+  return value;
+}
+function array(value: unknown, max: number): unknown[] {
+  if (!Array.isArray(value) || value.length > max) fail("Invalid composition list");
+  return value;
+}
+function stable(value: unknown): string {
+  if (Array.isArray(value)) return `[${value.map(stable).join(",")}]`;
+  if (value && typeof value === "object") return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${JSON.stringify(k)}:${stable(v)}`).join(",")}}`;
+  return JSON.stringify(value);
+}
+export function validateMediaPlan(input: unknown) {
+  const request = object(input), raw = object(request.plan);
+  fields(raw, ["schema_version", "title", "width", "height", "fps", "shots", "assets", "captions", "narration", "layout_template_id"]);
+  if (raw.schema_version !== MEDIA_PLAN_SCHEMA) fail("Unsupported composition schema");
+  const layout = layouts.templates.find(entry => entry.template_id === (raw.layout_template_id ?? "monochrome-editorial"));
+  if (!layout) fail("Select an existing content-ops layout template");
+  const width = number(raw.width, 320, 1920, true), height = number(raw.height, 240, 1080, true);
+  if (width % 2 || height % 2) fail("Video dimensions must be even");
+  const fps = number(raw.fps, 12, 30, true);
+  const assets = array(raw.assets ?? [], 20).map(value => {
+    const asset = object(value);
+    fields(asset, ["id", "path", "sha256", "kind", "source_ref", "visibility"]);
+    const path = text(asset.path, 400);
+    if (path.startsWith("/") || path.includes("\\") || path.split("/").some(part => part === ".." || !part || part === ".")) fail("Assets must be relative files inside the explicit source directory");
+    if (typeof asset.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(asset.sha256)) fail("Each source requires its exact SHA256");
+    if (typeof asset.kind !== "string" || !["image", "video", "audio"].includes(asset.kind)) fail("Unsupported asset kind");
+    if (typeof asset.visibility !== "string" || !["local_private", "public_safe"].includes(asset.visibility)) fail("Each source requires its visibility boundary");
+    return {id: token(asset.id), path, sha256: asset.sha256, kind: asset.kind as string,
+      source_ref: text(asset.source_ref, 240), visibility: asset.visibility as string};
+  });
+  if (new Set(assets.map(asset => asset.id)).size !== assets.length) fail("Duplicate source reference");
+  const shots = array(raw.shots, 30).map(value => {
+    const shot = object(value);
+    fields(shot, ["id", "kind", "seconds", "title", "body", "nodes", "asset_id", "start_seconds", "source_ref", "boundary"]);
+    const kind = shot.kind;
+    if (typeof kind !== "string" || !["title", "diagram", "excerpt"].includes(kind)) fail("Unsupported shot kind");
+    const base = {id: token(shot.id), kind, seconds: number(shot.seconds, 1, 30), title: text(shot.title, 100),
+      body: shot.body == null || shot.body === "" ? "" : text(shot.body, 300), source_ref: text(shot.source_ref, 240), boundary: text(shot.boundary, 180)};
+    if (kind === "diagram") {
+      const nodes = array(shot.nodes, 5).map(node => text(node, 48));
+      if (nodes.length < 2) fail("A diagram requires at least two nodes");
+      return {...base, nodes};
+    }
+    if (kind === "excerpt") {
+      const asset_id = token(shot.asset_id), asset = assets.find(entry => entry.id === asset_id);
+      if (!asset || !["image", "video"].includes(asset.kind)) fail("Excerpt source is missing or has the wrong kind");
+      return {...base, asset_id, start_seconds: number(shot.start_seconds ?? 0, 0, 86400)};
+    }
+    return base;
+  });
+  if (!shots.length || new Set(shots.map(shot => shot.id)).size !== shots.length) fail("Shots require distinct IDs");
+  const duration = shots.reduce((total, shot) => total + shot.seconds, 0);
+  if (duration > 90 || shots.some(shot => Math.abs(shot.seconds * fps - Math.round(shot.seconds * fps)) > 1e-7)) fail("Use frame-aligned shots within a 90-second composition");
+  let end = 0;
+  const captions = array(raw.captions ?? [], 80).map(value => {
+    const cue = object(value);
+    fields(cue, ["start", "end", "text", "language"]);
+    const start = number(cue.start, end, duration), stop = number(cue.end, start + 0.001, duration);
+    const language = text(cue.language, 12);
+    if (!/^[a-z]{2}(?:-[A-Z]{2})?$/.test(language)) fail("Invalid caption language");
+    const content = text(cue.text, 220);
+    if (content.includes("-->")) fail("Invalid caption delimiter");
+    end = stop;
+    return {start, end: stop, text: content, language};
+  });
+  const narration = object(raw.narration);
+  fields(narration, ["mode", "asset_id", "voice", "words_per_minute"]);
+  let sound: ObjectValue;
+  if (narration.mode === "supplied") {
+    fields(narration, ["mode", "asset_id"]);
+    const id = token(narration.asset_id);
+    if (!assets.some(asset => asset.id === id && asset.kind === "audio")) fail("Narration audio is missing");
+    sound = {mode: "supplied", asset_id: id};
+  } else if (narration.mode === "system_speech") {
+    fields(narration, ["mode", "voice", "words_per_minute"]);
+    if (!captions.length) fail("Timed system speech requires captions");
+    sound = {mode: "system_speech", voice: token(narration.voice), words_per_minute: number(narration.words_per_minute ?? 155, 90, 220, true)};
+  } else if (narration.mode === "silent") {fields(narration, ["mode"]); sound = {mode: "silent"};}
+  else fail("Select supplied audio, available system speech, or explicit silence");
+  const plan = {schema_version: MEDIA_PLAN_SCHEMA, title: text(raw.title, 100), width, height, fps, shots, assets, captions, narration: sound, layout_template_id: layout.template_id};
+  return {ok: true, plan, duration_seconds: duration, frame_count: Math.round(duration * fps),
+    plan_digest: `sha256:${createHash("sha256").update(stable({plan, layout_style: layout.style_tokens})).digest("hex")}`,
+    layout_style: layout.style_tokens,
+    capability_id: "content-ops", protocol: MEDIA_PROTOCOL, visibility: "local_private", publish_authorized: false};
+}
+
+/** Only validated, path-free result fields can enter the workbench projection. */
+export function validateMediaResult(input: unknown) {
+  const request = object(input), result = object(request.result), qa = object(result.qa), cost = object(result.cost);
+  if (result.ok !== true || result.protocol !== MEDIA_PROTOCOL || result.plan_digest !== request.plan_digest || result.publish_authorized !== false) fail("Renderer result is not bound to this composition");
+  if (qa.full_decode !== "passed" || qa.frames !== request.frame_count || qa.width !== request.width || qa.height !== request.height || qa.fps !== request.fps || qa.source_hashes_verified !== true) fail("Renderer did not qualify the declared timeline");
+  const entries = object(result.files), files: Record<string, {sha256: string; bytes: number}> = {};
+  const allowed = ["video.mp4", "poster.png", "captions.vtt", "captions.srt", "transcript.txt", "narration.wav"];
+  for (const [name, raw] of Object.entries(entries)) {
+    if (!allowed.includes(name)) fail("Unexpected renderer file");
+    const entry = object(raw);
+    if (typeof entry.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(entry.sha256)) fail("Invalid renderer digest");
+    files[name] = {sha256: entry.sha256, bytes: number(entry.bytes, 0, 128 * 1024 * 1024, true)};
+  }
+  if (["video.mp4", "poster.png", "captions.vtt", "captions.srt", "transcript.txt"].some(name => !files[name])) fail("Renderer output incomplete");
+  const narration = object(qa.narration);
+  if (!["silent", "supplied", "system_speech"].includes(String(narration.mode)) || narration.mode !== request.narration_mode) fail("Narration result differs from the admitted plan");
+  if (narration.mode !== "silent" && !files["narration.wav"]) fail("Narration output is missing");
+  const audioMetrics = narration.mode === "silent" ? {} : {
+    peak_dbfs: narration.peak_dbfs === null ? null : number(narration.peak_dbfs, -100, 0),
+    clipped_samples: number(narration.clipped_samples, 0, 44100 * 90, true),
+  };
+  return {ok: true, protocol: MEDIA_PROTOCOL, plan_digest: request.plan_digest, files,
+    qa: {full_decode: "passed", frames: qa.frames, width: qa.width, height: qa.height, fps: qa.fps,
+      source_hashes_verified: true, narration: {mode: narration.mode, ...audioMetrics, subjective_listening: "not_tested"},
+      audience_understanding: "not_tested", creative_review: "not_tested"},
+    cost: {render_wall_seconds: number(cost.render_wall_seconds, 0, 120)}, publish_authorized: false};
+}
+
+/** A private render attempt has no authority to transition a content item to published. */
+export function transitionMediaRender(input: unknown) {
+  const value = object(input), state = object(value.state);
+  number(state.revision, 1, Number.MAX_SAFE_INTEGER, true);
+  if (state.revision !== value.expected_revision) fail("Composition revision changed; inspect before retrying");
+  const current = state.status, action = value.action;
+  const allowed = action === "start" ? ["prepared", "failed", "cancelled", "interrupted", "ready"] : ["rendering"];
+  if (typeof current !== "string" || !allowed.includes(current)) fail("This render transition is unavailable");
+  const status = action === "start" ? "rendering" : action === "success" ? "ready" : action === "cancel" ? "cancelled" : action === "interrupt" ? "interrupted" : action === "failure" ? "failed" : fail("Unsupported render action");
+  const observedAt = text(value.observed_at, 40);
+  if (!/^\d{4}-\d\d-\d\dT/.test(observedAt) || !/(Z|[+-]\d\d:\d\d)$/.test(observedAt) || !Number.isFinite(Date.parse(observedAt))) fail("Render transition requires a timezone-aware observation");
+  return {ok: true, state: {...state, status, updated_at: observedAt}};
+}
diff --git a/loopx/control_plane/effect_runtime_handlers.ts b/loopx/control_plane/effect_runtime_handlers.ts
index 87fab6ef44..766ce9f503 100644
--- a/loopx/control_plane/effect_runtime_handlers.ts
+++ b/loopx/control_plane/effect_runtime_handlers.ts
@@ -680,6 +680,9 @@ export function createEffectRuntimeHandlers(
     ["content_reference.search", lazyHandler(() => import("./capabilities/content_reference.ts"), ({searchContentReferences}) => searchContentReferences)],
     ["content_reference.capture", lazyHandler(() => import("./capabilities/content_reference.ts"), ({captureContentReference}) => captureContentReference)],
     ["content_reference.draft", lazyHandler(() => import("./capabilities/content_reference.ts"), ({planReferenceDraft}) => planReferenceDraft)],
+    ["content_media.plan", lazyHandler(() => import("./capabilities/content_media.ts"), ({validateMediaPlan}) => validateMediaPlan)],
+    ["content_media.transition", lazyHandler(() => import("./capabilities/content_media.ts"), ({transitionMediaRender}) => transitionMediaRender)],
+    ["content_media.result", lazyHandler(() => import("./capabilities/content_media.ts"), ({validateMediaResult}) => validateMediaResult)],
     ["reward_memory.decision.plan", lazyHandler(() => import("./capabilities/reward_memory_decision.ts"), ({planRewardMemoryDecision}) => planRewardMemoryDecision)],
     ["reward_memory.decision.project", lazyHandler(() => import("./capabilities/reward_memory_decision.ts"), ({projectRewardMemoryDecision}) => projectRewardMemoryDecision)],
     ["reward_memory.read_authority.surface_checkpoints", lazyHandler(() => import("./capabilities/reward_memory_decision.ts"), ({buildRewardMemorySurfaceReadCheckpoints}) => buildRewardMemorySurfaceReadCheckpoints)],
diff --git a/loopx/presentation/configuration_api.py b/loopx/presentation/configuration_api.py
index 88fac0b905..f330fcb3ed 100644
--- a/loopx/presentation/configuration_api.py
+++ b/loopx/presentation/configuration_api.py
@@ -15,6 +15,7 @@
 from .. import chat_goal_configuration_api as goal_api
 from . import goal_direction_api as direction_api
 from . import decision_context_api as context_api
+from . import content_media_api as media_api
 from .. import chat_machine_configuration_api as machine_api
 from .. import chat_operator_provider_api as operator_api
 from .. import chat_automation_cadence_api as cadence_api
@@ -33,6 +34,7 @@ class ChatConfigurationRequestMixin(
     goal_api.GoalConfigurationRequestMixin,
     direction_api.GoalDirectionRequestMixin,
     context_api.DecisionContextRequestMixin,
+    media_api.ContentMediaRequestMixin,
     machine_api.MachineConfigurationRequestMixin,
     operator_api.OperatorProviderRequestMixin,
     backup_api.ConfigurationBackupRequestMixin,
@@ -42,6 +44,7 @@ class ChatConfigurationRequestMixin(
 
     def _configuration_get_routes(self) -> dict[str, Callable[[], None]]:
         return {
+            f"{media_api.CONTENT_MEDIA_PATH}/file": self._content_media_file,
             accounts_api.CODEX_ACCOUNTS_PATH: self._codex_accounts_read,
             attached_api.CODEX_ATTACHED_PATH: self._codex_attached_read,
             attached_api.CODEX_ATTACHED_LIVE_PATH: self._codex_attached_live,
@@ -62,6 +65,7 @@ def _configuration_get_routes(self) -> dict[str, Callable[[], None]]:
 
     def _configuration_post_routes(self) -> dict[str, Callable[[], None]]:
         return {
+            media_api.CONTENT_MEDIA_PATH: self._content_media_request,
             accounts_api.CODEX_ACCOUNTS_PATH: self._codex_accounts_write,
             context_api.DECISION_CONTEXT_PATH: self._decision_context_request,
             attached_api.CODEX_ATTACHED_PATH: self._codex_attached_send,
diff --git a/loopx/presentation/content_media_api.py b/loopx/presentation/content_media_api.py
new file mode 100644
index 0000000000..47a3615fca
--- /dev/null
+++ b/loopx/presentation/content_media_api.py
@@ -0,0 +1,88 @@
+"""Loopback transport for Goal-owned private content compositions."""
+from __future__ import annotations
+
+import mimetypes
+import os
+from pathlib import Path
+import re
+from typing import Any
+from urllib.parse import parse_qs, urlparse
+
+from ..capabilities.content_ops.media import MediaWorkspace
+from ..feedback import validate_goal_id
+from .goal_source_routing import source_registry_for_goal
+
+CONTENT_MEDIA_PATH = "/api/chat/content-media"
+
+
+class ContentMediaRequestMixin:
+    server: Any
+    path: str
+
+    def _media_workspace(self, goal_id: str) -> MediaWorkspace:
+        validate_goal_id(goal_id)
+        selected = getattr(self.server, "selected_goal_id", None)
+        if selected and selected != goal_id: raise ValueError("Goal is outside this workspace")
+        source = source_registry_for_goal(self.server.registry_path, goal_id)
+        return MediaWorkspace(registry_path=Path(source), goal_id=goal_id, runtime_root=Path(self.server.runtime_root))
+
+    def _content_media_request(self) -> None:
+        try:
+            if urlparse(self.path).query: raise ValueError("Use the request body")
+            body = self._read_json(max_bytes=4096)
+            if set(body) - {"goal_id", "action", "composition_id", "expected_revision"}: raise ValueError("Unsupported fields")
+            workspace = self._media_workspace(body["goal_id"])
+            action = body["action"]
+            if action == "list" and set(body) == {"goal_id", "action"}:
+                result = workspace.list()
+            elif action == "inspect" and set(body) == {"goal_id", "action", "composition_id"}:
+                result = workspace.inspect(body["composition_id"])
+            elif action in {"render", "cancel"} and set(body) == {"goal_id", "action", "composition_id", "expected_revision"}:
+                revision = body["expected_revision"]
+                if isinstance(revision, bool) or not isinstance(revision, int): raise ValueError("Read the current revision")
+                method = workspace.render if action == "render" else workspace.cancel
+                result = method(body["composition_id"], expected_revision=revision, **({"background": True} if action == "render" else {}))
+            else: raise ValueError("Unsupported operation")
+            self._send_json(result)
+        except (OSError, ValueError, TypeError, KeyError, RuntimeError):
+            self._send_error("Video request unavailable. Reopen the selected Goal and composition, then retry.", status=400)
+
+    def _content_media_file(self) -> None:
+        try:
+            query = parse_qs(urlparse(self.path).query, strict_parsing=True)
+            if set(query) != {"goal_id", "composition_id", "file"} or any(len(v) != 1 for v in query.values()):
+                raise ValueError("Invalid file request")
+            workspace = self._media_workspace(query["goal_id"][0])
+            name = query["file"][0]
+            path = workspace.file(query["composition_id"][0], name)
+            fd = os.open(path, os.O_RDONLY | getattr(os, "O_NOFOLLOW", 0))
+            with os.fdopen(fd, "rb") as source:
+                size = os.fstat(source.fileno()).st_size
+                start, end, status = 0, size - 1, 200
+                header = self.headers.get("Range")
+                if header:
+                    match = re.fullmatch(r"bytes=(\d+)-(\d*)", header)
+                    if not match: raise ValueError("Unsupported byte range")
+                    start, end = int(match[1]), min(int(match[2]) if match[2] else size - 1, size - 1)
+                    if not 0 <= start <= end < size: raise ValueError("Invalid byte range")
+                    status = 206
+                self.send_response(status)
+                self.send_header("Content-Type", "text/vtt; charset=utf-8" if name.endswith(".vtt") else mimetypes.guess_type(name)[0] or "application/octet-stream")
+                self.send_header("Content-Length", str(end - start + 1))
+                self.send_header("Content-Disposition", f'inline; filename="{name}"')
+                self.send_header("Accept-Ranges", "bytes")
+                self.send_header("Cache-Control", "no-store")
+                self.send_header("Cross-Origin-Resource-Policy", "same-origin")
+                self.send_header("X-Content-Type-Options", "nosniff")
+                if status == 206: self.send_header("Content-Range", f"bytes {start}-{end}/{size}")
+                self.end_headers()
+                source.seek(start)
+                remaining = end - start + 1
+                while remaining:
+                    chunk = source.read(min(remaining, 65536))
+                    if not chunk: break
+                    self.wfile.write(chunk); remaining -= len(chunk)
+        except (BrokenPipeError, ConnectionResetError):
+            return
+        except (OSError, ValueError, TypeError, KeyError):
+            self._send_error("Verified video file unavailable.", status=404)
diff --git a/packages/loopx-media/README.md b/packages/loopx-media/README.md
new file mode 100644
index 0000000000..66cfcebb92
--- /dev/null
+++ b/packages/loopx-media/README.md
@@ -0,0 +1,90 @@
+# Local video renderer
+
+`loopx-media` is an optional distribution for the existing **content-ops**
+capability. It renders an admitted composition; it does not choose sources,
+run commands from a brief, use an account, call a model, or publish a movie.
+Shared TypeScript admission and render transitions remain in LoopX core.
+Pillow, FontTools, FFmpeg and platform speech are specialized local computation.
+
+From a source checkout, install the executable and register its manifest:
+
+```sh
+uv tool install ./packages/loopx-media
+loopx extension install --manifest packages/loopx-media/extension.toml --execute
+loopx extension doctor loopx-media --execute
+```
+
+The LoopX process must have `loopx-media` on its PATH. Installation explicitly
+enables the local extension. No renderer is installed, enabled or downloaded
+by `content-ops media prepare`, page loading or a missing-provider read.
+The manifest requests `content_media_write` for private composition output.
+Use the existing extension state owner; there is no second media setting.
+An isolated environment is also supported if its executable is on that PATH.
+
+An Agent prepares the story, source SHA256s and timing through
+[`content-ops media`](../../docs/reference/protocols/content-ops-media-v0.md).
+In the packaged App, open **Settings → Capabilities → a Goal → Content
+production**. Select the prepared composition, render, then view the video,
+captions, transcript and source boundaries in the same workbench. The CLI
+exposes the same operation. Rendering is local work; it grants no publication
+approval. Revise the brief through the Agent rather than re-entering source
+paths or protocol JSON in the browser.
+
+Supported atoms are title scenes, measured text wrapping, animated node
+diagrams, hash-bound image/video excerpts, timed captions, supplied audio,
+macOS system speech, H.264/AAC encoding, a first-frame poster and full video
+decode. Images retain their orientation; video excerpts retain aspect ratio.
+Installed fonts must cover the visible text, with CJK line breaking supported.
+RTL shaping and arbitrary font discovery are not qualified. macOS speech is
+optional; other platforms require supplied audio or explicit silence.
+No cloud voice, generative image/video, Blender or game engine is bundled here.
+
+The renderer refuses a short excerpt, changed source, missing glyphs, text
+overflow or speech longer than its cue. It does not fill missing footage,
+silently truncate text or speed up speech to hide those failures. Prepare a
+new revision for story/source/timing changes. Repair a local dependency and
+run doctor again before retrying an unchanged brief. Cancellation is requested
+in place and read back after the worker stops; a host interruption is recovered
+by an explicit retry. An intact completed result is reused without encoding
+again. Damaged result bytes cannot be downloaded as verified output.
+
+## Bounds and review
+
+Plans are limited to 90 seconds, 30 shots, 20 local assets and 80 ordered
+caption cues, with at most 1920×1080 at 30 fps. Each source is at most 64 MiB;
+all source snapshots together are at most 128 MiB. The render has a 120-second
+process budget. A complex valid plan can exceed the local machine's budget;
+that is a failed attempt, not a reason to mark a partial movie ready.
+
+The result records exact output digests, decoded frames, render wall time,
+PCM peak/clipping measurements when audio exists, and untested creative,
+listening and audience-understanding judgments. These mechanical checks do
+not establish narration quality, factual truth, source rights, learning gain,
+virality or a better film. Review the actual result before sharing. Existing
+content-item approval and delivery intent are invalidated when the plan or
+rendered bytes change. The outputs remain private until separately authorized.
+
+Disable new renders with the existing owner:
+
+```sh
+loopx extension disable loopx-media --execute
+```
+
+Existing verified results remain readable. Re-enable and run doctor after a
+dependency repair. Prepared files and failed attempts remain in the registered
+project's private `.local/content-media/` directory for inspection; disabling
+does not delete them. There is no automatic cleanup of source evidence.
+
+## Focused validation
+
+Core tests do not need this distribution. To exercise the actual optional
+extension, encoder, source reuse, recovery and HTTP byte serving after installing
+the executable in an isolated environment:
+
+```sh
+LOOPX_MEDIA_RENDERER_TEST=1 uv run --extra test pytest -q tests/test_content_media.py
+node --test tests/control_plane_ts/content_media.test.ts
+```
+
+The opt-in test uses synthetic local sources and no model or cloud service.
+It is integration evidence, not a subjective or comparative creative study.
diff --git a/packages/loopx-media/extension.toml b/packages/loopx-media/extension.toml
new file mode 100644
index 0000000000..258b6b5005
--- /dev/null
+++ b/packages/loopx-media/extension.toml
@@ -0,0 +1,16 @@
+schema_version = "loopx_extension_manifest_v0"
+id = "loopx-media"
+version = "0.1.0"
+requires_loopx_api = ">=1,<2"
+permissions = ["content_media_write"]
+
+[runtime]
+protocol = "content_ops_media_renderer_v0"
+entrypoint = "loopx-media"
+doctor_args = ["--doctor"]
+required_permissions = ["content_media_write"]
+timeout_seconds = 120
+
+[[implements]]
+capability_id = "content-ops"
+protocol = "content_ops_media_renderer_v0"
diff --git a/packages/loopx-media/pyproject.toml b/packages/loopx-media/pyproject.toml
new file mode 100644
index 0000000000..623ee5d25a
--- /dev/null
+++ b/packages/loopx-media/pyproject.toml
@@ -0,0 +1,16 @@
+[build-system]
+requires = ["setuptools>=69"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "loopx-media"
+version = "0.1.0"
+description = "Optional local composition renderer for LoopX content-ops"
+requires-python = ">=3.11"
+dependencies = ["Pillow>=11,<13", "imageio-ffmpeg>=0.6,<0.7", "fonttools>=4,<5"]
+
+[project.scripts]
+loopx-media = "loopx_media.renderer:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
diff --git a/packages/loopx-media/src/loopx_media/__init__.py b/packages/loopx-media/src/loopx_media/__init__.py
new file mode 100644
index 0000000000..5aa835a432
--- /dev/null
+++ b/packages/loopx-media/src/loopx_media/__init__.py
@@ -0,0 +1 @@
+"""Optional specialized media computation; core owns composition admission."""
diff --git a/packages/loopx-media/src/loopx_media/renderer.py b/packages/loopx-media/src/loopx_media/renderer.py
new file mode 100644
index 0000000000..5e6d2c6618
--- /dev/null
+++ b/packages/loopx-media/src/loopx_media/renderer.py
@@ -0,0 +1,301 @@
+"""Bounded local rendering. Stdin is an admitted private composition envelope.
+
+No account, network, arbitrary command, source-directory discovery or publication.
+The content-ops caller provides immutable source snapshots and an exclusive attempt
+directory. This renderer implements the protocol; it does not admit that effect.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from pathlib import Path
+import re
+import subprocess
+import sys
+import time
+import wave
+import array
+import math
+
+import imageio_ffmpeg
+from PIL import Image, ImageDraw, ImageFont, ImageOps
+from fontTools.ttLib import TTFont
+
+PROTOCOL = "content_ops_media_renderer_v0"
+INK, MUTED, BLUE, LINE = "#182031", "#657087", "#2768ea", "#dce3f0"
+Image.MAX_IMAGE_PIXELS = 16_000_000
+
+
+class RenderCancelled(Exception):
+    pass
+
+
+def digest(path: Path) -> str:
+    with path.open("rb") as source:
+        return hashlib.file_digest(source, "sha256").hexdigest()
+
+
+def run(argv: list[str], *, timeout: int = 30) -> subprocess.CompletedProcess:
+    return subprocess.run(argv, capture_output=True, check=True, timeout=timeout)
+
+
+def font_file(content: str = "LoopX") -> str | None:
+    required = {ord(char) for char in content if not char.isspace()}
+    for name in ("/System/Library/Fonts/Supplemental/Arial.ttf",
+                 "/System/Library/Fonts/Supplemental/Arial Unicode.ttf",
+                 "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
+                 "/usr/share/fonts/opentype/noto/NotoSansCJK-Regular.ttc",
+                 "C:/Windows/Fonts/arial.ttf"):
+        if Path(name).is_file():
+            with TTFont(name, fontNumber=0, lazy=True) as font:
+                if required <= set(font.getBestCmap() or {}): return name
+    return None
+
+
+def stamp(seconds: float, *, srt: bool = False) -> str:
+    milliseconds = round(seconds * 1000)
+    hours, milliseconds = divmod(milliseconds, 3600000)
+    minutes, milliseconds = divmod(milliseconds, 60000)
+    seconds, milliseconds = divmod(milliseconds, 1000)
+    return f"{hours:02}:{minutes:02}:{seconds:02}{',' if srt else '.'}{milliseconds:03}"
+
+
+def captions(plan: dict, out: Path) -> None:
+    vtt, srt, transcript = ["WEBVTT\n"], [], [plan["title"]]
+    for i, cue in enumerate(plan["captions"], 1):
+        vtt.append(f"{i}\n{stamp(cue['start'])} --> {stamp(cue['end'])}\n{cue['text']}\n")
+        srt.append(f"{i}\n{stamp(cue['start'], srt=True)} --> {stamp(cue['end'], srt=True)}\n{cue['text']}\n")
+        transcript.append(f"{cue['start']:g}–{cue['end']:g}s · {cue['text']}")
+    for filename, lines in (("captions.vtt", vtt), ("captions.srt", srt), ("transcript.txt", transcript)):
+        (out / filename).write_text("\n\n".join(lines) + "\n", encoding="utf-8")
+
+
+def soundtrack(plan: dict, sources: dict[str, Path], out: Path, ff: str, check) -> dict:
+    mode = plan["narration"]["mode"]
+    duration = sum(shot["seconds"] for shot in plan["shots"])
+    destination = out / "narration.wav"
+    if mode == "silent":
+        return {"mode": mode, "subjective_listening": "not_tested"}
+    if mode == "supplied":
+        run([ff, "-v", "error", "-n", "-i", str(sources[plan["narration"]["asset_id"]]),
+             "-vn", "-ar", "44100", "-ac", "1", "-c:a", "pcm_s16le", str(destination)])
+        with wave.open(str(destination)) as audio:
+            seconds = audio.getnframes() / audio.getframerate()
+        if abs(seconds - duration) > 0.1:
+            raise ValueError("Audio duration differs from the composition; revise timing explicitly")
+        return {"mode": mode, "seconds": seconds, "subjective_listening": "not_tested"}
+    if sys.platform != "darwin" or not Path("/usr/bin/say").is_file():
+        raise ValueError("System speech unavailable; supply a timed audio asset or choose explicit silence")
+    timeline = bytearray(round(duration * 44100) * 2)
+    rows = []
+    for i, cue in enumerate(plan["captions"]):
+        check()
+        text, aiff, wav = (out / f"voice-{i}.{suffix}" for suffix in ("txt", "aiff", "wav"))
+        text.write_text(cue["text"], encoding="utf-8")
+        run(["/usr/bin/say", "-v", plan["narration"]["voice"], "-r", str(plan["narration"]["words_per_minute"]), "-f", str(text), "-o", str(aiff)])
+        run([ff, "-v", "error", "-n", "-i", str(aiff), "-ar", "44100", "-ac", "1", "-c:a", "pcm_s16le", str(wav)])
+        with wave.open(str(wav)) as audio:
+            samples, rate = audio.readframes(audio.getnframes()), audio.getframerate()
+        actual = len(samples) / 2 / rate
+        if actual > cue["end"] - cue["start"] - 0.15:
+            raise ValueError("Narration exceeds its cue; extend the brief instead of silently speeding speech")
+        start = round((cue["start"] + 0.075) * 44100) * 2
+        timeline[start:start + len(samples)] = samples
+        rows.append({"cue": i, "speech_seconds": actual})
+        for path in (text, aiff, wav):
+            path.unlink()
+    with wave.open(str(destination), "wb") as audio:
+        audio.setnchannels(1); audio.setsampwidth(2); audio.setframerate(44100); audio.writeframes(timeline)
+    return {"mode": mode, "cues": rows, "subjective_listening": "not_tested"}
+
+
+def render(request: dict) -> dict:
+    if request.get("protocol") != PROTOCOL:
+        raise ValueError("Unsupported renderer protocol")
+    plan, out = request["plan"], Path(request["attempt_directory"])
+    out.mkdir(mode=0o700, exist_ok=False)
+    started = time.monotonic()
+    cancel = Path(request["cancel_file"])
+
+    def check():
+        if cancel.exists():
+            raise RenderCancelled()
+        if time.monotonic() - started > 105:
+            raise TimeoutError("Composition exceeded the bounded render duration")
+
+    sources = {}
+    for asset in plan["assets"]:
+        path = Path(request["sources"][asset["id"]])
+        if path.is_symlink() or not path.is_file() or digest(path) != asset["sha256"]:
+            raise ValueError("Source bytes changed; prepare a new revision")
+        sources[asset["id"]] = path
+    ff = imageio_ffmpeg.get_ffmpeg_exe()
+    captions(plan, out)
+    audio = soundtrack(plan, sources, out, ff, check)
+    width, height, fps = plan["width"], plan["height"], plan["fps"]
+    scale = width / 1280
+    style = request["layout_style"]
+    ink, muted, accent = style["text"], style["muted"], style["accent"]
+    visible_text = "LOOPX / CONTENT STUDIO " + " ".join(
+        shot["title"] + " " + shot["body"] + " " + shot["boundary"] + " " + " ".join(shot.get("nodes", []))
+        for shot in plan["shots"])
+    font_path = font_file(visible_text)
+    if not font_path: raise ValueError("No installed font covers this brief; install a suitable font before retrying")
+    fonts = {}
+
+    def font(size):
+        pixels = max(12, round(size * scale))
+        if pixels not in fonts:
+            fonts[pixels] = ImageFont.truetype(font_path, pixels) if font_path else ImageFont.load_default(size=pixels)
+        return fonts[pixels]
+
+    def draw_text(draw, position, text, size, color=INK, max_width=None, max_lines=4):
+        selected = font(size)
+        limit = max_width or width - position[0] * 2
+        lines, current = [], ""
+        # Preserve English words and allow CJK line breaks without inventing
+        # spaces or silently drawing missing-glyph boxes.
+        previous_cjk = False
+        for word in re.findall(r"[\u2e80-\u9fff\uf900-\ufaff]|[^\s\u2e80-\u9fff\uf900-\ufaff]+", text):
+            cjk = bool(re.fullmatch(r"[\u2e80-\u9fff\uf900-\ufaff]", word))
+            candidate = current + (" " if current and not cjk and not previous_cjk else "") + word
+            if draw.textlength(candidate, font=selected) > limit and current:
+                lines.append(current); current = word
+            else:
+                current = candidate
+            previous_cjk = cjk
+        if current: lines.append(current)
+        if len(lines) > max_lines or any(draw.textlength(line, font=selected) > limit for line in lines):
+            raise ValueError("Text exceeds the layout; revise or split the shot")
+        x, y = position
+        for line in lines:
+            draw.text((x, y), line, fill=color, font=selected)
+            y += round(size * scale * 1.35)
+        return y
+
+    video = out / "video.mp4"
+    encoder = subprocess.Popen([ff, "-v", "error", "-n", "-f", "rawvideo", "-pix_fmt", "rgb24", "-s", f"{width}x{height}", "-r", str(fps), "-i", "pipe:0", "-an", "-c:v", "libx264", "-threads", "2", "-preset", "veryfast", "-crf", "19", "-pix_fmt", "yuv420p", "-movflags", "+faststart", str(out / "silent.mp4")], stdin=subprocess.PIPE, stderr=subprocess.DEVNULL)
+    frames = 0
+    try:
+        for index, shot in enumerate(plan["shots"]):
+            count = round(shot["seconds"] * fps)
+            decoder = None
+            source_image = None
+            if shot["kind"] == "excerpt":
+                asset = next(a for a in plan["assets"] if a["id"] == shot["asset_id"])
+                if asset["kind"] == "image":
+                    source_image = ImageOps.exif_transpose(Image.open(sources[asset["id"]])).convert("RGB")
+                else:
+                    # Set the frame clock before scaling; a trailing fps filter
+                    # after swscale can lose the final source frame at EOF.
+                    decoder = subprocess.Popen([ff, "-v", "error", "-ss", str(shot["start_seconds"]), "-i", str(sources[asset["id"]]), "-t", str(shot["seconds"]), "-vf", f"fps={fps},scale={width}:{height}:force_original_aspect_ratio=decrease,pad={width}:{height}:(ow-iw)/2:(oh-ih)/2:color={style['background']}", "-f", "rawvideo", "-pix_fmt", "rgb24", "pipe:1"], stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)
+            try:
+                for n in range(count):
+                    check()
+                    im = Image.new("RGB", (width, height), style["background"])
+                    draw = ImageDraw.Draw(im)
+                    margin = round(56 * scale)
+                    draw_text(draw, (margin, round(27 * scale)), "LOOPX / CONTENT STUDIO", 16, accent)
+                    draw.line((margin, round(65 * scale), width - margin, round(65 * scale)), fill=LINE)
+                    if shot["kind"] == "excerpt":
+                        frame = source_image
+                        if decoder:
+                            raw = decoder.stdout.read(width * height * 3)
+                            if len(raw) != width * height * 3:
+                                raise ValueError("Excerpt is shorter than the declared shot; no frozen-frame substitution")
+                            frame = Image.frombytes("RGB", (width, height), raw)
+                        fitted = frame.copy()
+                        fitted.thumbnail((width - 2 * margin, round(height * 0.62)))
+                        im.paste(fitted, ((width - fitted.width) // 2, round(height * 0.27)))
+                        draw_text(draw, (margin, round(88 * scale)), shot["title"], 32, ink, max_lines=2)
+                    else:
+                        enter = 1 - (1 - min(1, n / max(1, fps * 0.6))) ** 3
+                        y = round((125 + 16 * (1 - enter)) * scale)
+                        bottom = draw_text(draw, (margin, y), shot["title"], 48, ink, max_lines=3)
+                        if shot["body"]:
+                            bottom = draw_text(draw, (margin, bottom + round(24 * scale)), shot["body"], 25, muted, max_lines=3)
+                        if bottom > height * (.57 if shot["kind"] == "diagram" else .85):
+                            raise ValueError("Text overlaps the scene; revise or split the shot")
+                        if shot["kind"] == "diagram":
+                            nodes = shot["nodes"]
+                            gap = round(22 * scale)
+                            box_w = (width - 2 * margin - gap * (len(nodes) - 1)) // len(nodes)
+                            y, h = round(height * .60), round(height * .19)
+                            for j, label in enumerate(nodes):
+                                x = margin + j * (box_w + gap)
+                                progress = max(0, min(1, (n / fps - j * .3) / .65))
+                                active = progress > 0
+                                draw.rounded_rectangle((x, y, x + box_w, y + h), radius=round(10 * scale), fill=style["background"], outline=accent if active else LINE, width=2)
+                                node_end = draw_text(draw, (x + round(13 * scale), y + round(20 * scale)), label, 22, ink if active else muted, max_width=box_w - round(26 * scale), max_lines=3)
+                                if node_end > y + h - 8: raise ValueError("Node label overflows; shorten or split the diagram")
+                                if j:
+                                    a, b = x - gap + 4, x - 4
+                                    draw.line((a, y + h / 2, a + (b - a) * progress, y + h / 2), fill=accent, width=2)
+                                    if progress == 1:
+                                        draw.polygon(((b, y+h/2), (b-6, y+h/2-4), (b-6, y+h/2+4)), fill=accent)
+                    draw_text(draw, (margin, height - round(56 * scale)), shot["boundary"], 16, muted, max_lines=2)
+                    bar = margin + (width - 2 * margin) * (frames / request["frame_count"])
+                    draw.line((margin, height-8, bar, height-8), fill=accent, width=3)
+                    if frames == 0: im.save(out / "poster.png")
+                    encoder.stdin.write(im.tobytes()); frames += 1
+            finally:
+                if decoder:
+                    decoder.stdout.close()
+                    decoder.terminate()
+                    try: decoder.wait(timeout=3)
+                    except subprocess.TimeoutExpired: decoder.kill(); decoder.wait()
+        encoder.stdin.close()
+        if encoder.wait(timeout=15) != 0: raise ValueError("Video encoder failed")
+    finally:
+        if encoder.poll() is None:
+            encoder.kill(); encoder.wait()
+    check()
+    if audio["mode"] == "silent":
+        (out / "silent.mp4").rename(video)
+    else:
+        run([ff, "-v", "error", "-n", "-i", str(out / "silent.mp4"), "-i", str(out / "narration.wav"), "-map", "0:v:0", "-map", "1:a:0", "-c:v", "copy", "-c:a", "aac", "-b:a", "160k", "-movflags", "+faststart", str(video)])
+        (out / "silent.mp4").unlink()
+    decoded = run([ff, "-v", "error", "-nostats", "-progress", "pipe:1", "-i", str(video), "-f", "null", "-"])
+    counts = re.findall(rb"^frame=(\d+)$", decoded.stdout, re.M)
+    if not counts or int(counts[-1]) != request["frame_count"] or frames != request["frame_count"]:
+        raise ValueError("Full decode frame count differs from the plan")
+    if audio["mode"] != "silent":
+        with wave.open(str(out / "narration.wav")) as wav:
+            samples = array.array("h", wav.readframes(wav.getnframes()))
+        if sys.byteorder != "little": samples.byteswap()
+        peak = max((abs(sample) for sample in samples), default=0)
+        audio.update(peak_dbfs=round(20 * math.log10(peak / 32768), 2) if peak else None,
+                     clipped_samples=sum(abs(sample) >= 32767 for sample in samples))
+    files = {path.name: {"sha256": digest(path), "bytes": path.stat().st_size} for path in out.iterdir() if path.is_file()}
+    result = {"ok": True, "protocol": PROTOCOL, "plan_digest": request["plan_digest"], "files": files,
+              "qa": {"full_decode": "passed", "frames": frames, "width": width, "height": height, "fps": fps,
+                     "source_hashes_verified": True, "narration": audio, "audience_understanding": "not_tested", "creative_review": "not_tested"},
+              "cost": {"render_wall_seconds": round(time.monotonic() - started, 3)}, "publish_authorized": False}
+    (out / "manifest.json").write_text(json.dumps(result, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    return result
+
+
+def main() -> int:
+    os.umask(0o077)
+    try:
+        if sys.argv[1:] == ["--doctor"]:
+            ff = imageio_ffmpeg.get_ffmpeg_exe()
+            run([ff, "-version"], timeout=5)
+            if not font_file(): raise ValueError("Install a supported local font")
+            print(json.dumps({"ok": True, "protocol": PROTOCOL, "system_speech": sys.platform == "darwin", "font": "system"}))
+            return 0
+        raw = sys.stdin.buffer.read(1024 * 1024 + 1)
+        if len(raw) > 1024 * 1024: raise ValueError("Render request exceeds the protocol limit")
+        result = render(json.loads(raw))
+    except RenderCancelled:
+        result = {"ok": False, "error_code": "cancelled"}
+    except (OSError, ValueError, KeyError, TypeError, TimeoutError, subprocess.SubprocessError):
+        # Private text, source paths and subprocess stderr must not escape.
+        result = {"ok": False, "error_code": "render_failed"}
+    print(json.dumps(result, ensure_ascii=False))
+    return 0 if result["ok"] else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/tests/control_plane_ts/content_media.test.ts b/tests/control_plane_ts/content_media.test.ts
new file mode 100644
index 0000000000..183fc929cd
--- /dev/null
+++ b/tests/control_plane_ts/content_media.test.ts
@@ -0,0 +1,71 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {validateMediaPlan as plan, validateMediaResult as result, transitionMediaRender as transition} from "../../loopx/control_plane/capabilities/content_media.ts";
+
+const brief = () => ({schema_version: "content_ops_media_plan_v0", title: "Return the evidence", width: 1280, height: 720, fps: 24,
+  shots: [{id: "flow", kind: "diagram", seconds: 6, title: "A complete handoff", nodes: ["Intent", "Owner", "Evidence"], source_ref: "synthetic:handoff", boundary: "Mechanism illustration"}],
+  assets: [], captions: [{start: 0, end: 6, text: "Return evidence to the requester.", language: "en"}], narration: {mode: "silent"}});
+
+test("one composition digest binds story, timing, narration, source and scope", () => {
+  const original = plan({plan: brief()});
+  assert.equal(original.frame_count, 144);
+  assert.equal(original.publish_authorized, false);
+  assert.equal(original.visibility, "local_private");
+  assert.equal(plan({plan: JSON.parse(JSON.stringify(brief()))}).plan_digest, original.plan_digest);
+  assert.equal(plan({plan: original.plan}).plan_digest, original.plan_digest, "canonical plans must be replayable even with an empty optional body");
+  for (const changed of [
+    {...brief(), title: "Revised story"}, {...brief(), fps: 30},
+    {...brief(), layout_template_id: "control-plane-hybrid"},
+    {...brief(), captions: [{start: 0, end: 6, text: "Different claim", language: "en"}]},
+    {...brief(), narration: {mode: "system_speech", voice: "Samantha"}},
+    {...brief(), assets: [{id: "a", kind: "image", path: "screenshot.png", sha256: "a".repeat(64), source_ref: "synthetic:source", visibility: "local_private"}]},
+  ]) assert.notEqual(plan({plan: changed}).plan_digest, original.plan_digest);
+});
+
+test("renderer readback cannot change the admitted narration, frame count or output scope", () => {
+  const expected = {plan_digest: "sha256:" + "a".repeat(64), frame_count: 144, width: 1280, height: 720, fps: 24, narration_mode: "silent"};
+  const output = {ok: true, protocol: "content_ops_media_renderer_v0", plan_digest: expected.plan_digest,
+    files: Object.fromEntries(["video.mp4", "poster.png", "captions.vtt", "captions.srt", "transcript.txt"].map(name => [name, {sha256: "b".repeat(64), bytes: 16}])),
+    qa: {full_decode: "passed", frames: 144, width: 1280, height: 720, fps: 24, source_hashes_verified: true, narration: {mode: "silent"}, creative_review: "passed"},
+    cost: {render_wall_seconds: 1}, publish_authorized: false, private_path: "must-not-project"};
+  const projected = result({...expected, result: output});
+  assert.equal(projected.qa.creative_review, "not_tested");
+  assert.equal("private_path" in projected, false);
+  for (const changed of [
+    {...output, publish_authorized: true},
+    {...output, files: {...output.files, "../outside.mp4": {sha256: "b".repeat(64), bytes: 16}}},
+    {...output, qa: {...output.qa, frames: 143}},
+    {...output, qa: {...output.qa, narration: {mode: "supplied"}}},
+    {...output, files: {...output.files, "video.mp4": {sha256: "invalid", bytes: 16}}},
+  ]) assert.throws(() => result({...expected, result: changed}));
+});
+
+test("reject escaping assets, wrong kinds, ambiguous timing and overflow", () => {
+  for (const path of ["../secret", "/etc/passwd", "a/../b", "a\\b", "a//b"]) {
+    assert.throws(() => plan({plan: {...brief(), assets: [{id: "a", kind: "image", path, sha256: "a".repeat(64), source_ref: "source:1", visibility: "local_private"}]}}));
+  }
+  for (const invalid of [
+    {...brief(), width: 1279}, {...brief(), fps: 240}, {...brief(), shots: []},
+    {...brief(), shots: [{...brief().shots[0], seconds: 6.01}]},
+    {...brief(), shots: [{...brief().shots[0], kind: ["diagram"]}]},
+    {...brief(), assets: [{id: "a", kind: ["image"], path: "source.png", sha256: "a".repeat(64), source_ref: "synthetic:source", visibility: "local_private"}]},
+    {...brief(), assets: [{id: "a", kind: "image", path: "source.png", sha256: "a".repeat(64), source_ref: "synthetic:source", visibility: ["public_safe"]}]},
+    {...brief(), shots: [{...brief().shots[0], kind: "excerpt", asset_id: "missing"}]},
+    {...brief(), captions: [{start: 3, end: 7, text: "Past the end", language: "en"}]},
+    {...brief(), narration: {mode: "supplied", asset_id: "missing"}},
+    {...brief(), publish_authorized: true},
+  ]) assert.throws(() => plan({plan: invalid}));
+});
+
+test("render transitions are revision-bound and separate from publication", () => {
+  const state = {status: "prepared", revision: 2, publish_authorized: false};
+  const running = transition({state, expected_revision: 2, action: "start", observed_at: "2026-09-01T00:00:00Z"}).state;
+  assert.equal(running.status, "rendering");
+  for (const action of ["success", "failure", "cancel", "interrupt"]) {
+    const result = transition({state: running, expected_revision: 2, action, observed_at: "2026-09-01T00:00:01Z"}).state;
+    assert.equal(result.publish_authorized, false);
+  }
+  assert.throws(() => transition({state, expected_revision: 1, action: "start", observed_at: "now"}), /revision/);
+  assert.throws(() => transition({state, expected_revision: 2, action: "success", observed_at: "now"}), /unavailable/);
+  assert.throws(() => transition({state: running, expected_revision: 2, action: "publish", observed_at: "now"}));
+});
diff --git a/tests/test_content_media.py b/tests/test_content_media.py
new file mode 100644
index 0000000000..37d8d67b18
--- /dev/null
+++ b/tests/test_content_media.py
@@ -0,0 +1,218 @@
+"""Composition admission, optional effects and real loopback file boundaries."""
+from __future__ import annotations
+
+from copy import deepcopy
+from datetime import datetime, timedelta, timezone
+import hashlib
+import http.client
+import json
+import os
+from pathlib import Path
+import shutil
+import threading
+import time
+import wave
+
+import pytest
+
+from loopx.capabilities.content_ops import media
+from loopx.capabilities.content_ops.item_lifecycle import apply_content_ops_item_event
+from loopx.chat_server import ChatHTTPServer, ChatRequestHandler
+from loopx.control_plane.effect_runtime import EffectRuntimeRejected
+
+
+def brief():
+    return {"schema_version": "content_ops_media_plan_v0", "title": "Return the result", "width": 640, "height": 360, "fps": 12,
+            "shots": [{"id": "flow", "kind": "diagram", "seconds": 3, "title": "A complete handoff", "nodes": ["Intent", "Owner", "Evidence"],
+                       "source_ref": "synthetic:handoff", "boundary": "Mechanism illustration"}],
+            "captions": [{"start": 0, "end": 3, "text": "Return evidence to the requester.", "language": "en"}], "narration": {"mode": "silent"}}
+
+
+@pytest.fixture
+def workspace(tmp_path):
+    project = tmp_path / "project"
+    project.mkdir()
+    runtime = tmp_path / "runtime"
+    registry = tmp_path / "registry.json"
+    registry.write_text(json.dumps({"schema_version": "0.1", "common_runtime_root": str(runtime),
+        "goals": [{"id": "media-demo", "repo": str(project), "status": "active"}]}))
+    return media.MediaWorkspace(registry_path=registry, goal_id="media-demo", runtime_root=runtime), registry
+
+
+def test_prepare_is_replayable_and_revision_invalidates_publication_approval(workspace):
+    work, _ = workspace
+    first = work.prepare(brief(), source_directory=work.project)
+    same = work.prepare(brief(), source_directory=work.project, composition_id=first["composition_id"], expected_revision=1)
+    assert same["revision"] == 1
+    assert first["provider"]["status"] != "ready"
+    record = work._record(first["composition_id"])
+    item = record["item"]
+    for action, payload in [("submit_review", {}), ("approve", {"approval_ref": "decision:owner", "content_digest": item["content_digest"], "revision": item["revision"], "effect_kind": "publish"})]:
+        item = apply_content_ops_item_event(item, {"event_id": action, "action": action, "payload": payload,
+            "expected_state": item["state"], "expected_revision": item["revision"], "occurred_at": media.now()})["item"]
+    record["item"] = item
+    media._save(work._bundle(first["composition_id"]) / "record.json", record)
+    changed = {**brief(), "title": "Revised claim"}
+    with pytest.raises(ValueError, match="revision"):
+        work.prepare(changed, source_directory=work.project, composition_id=first["composition_id"], expected_revision=0)
+    revised = work.prepare(changed, source_directory=work.project, composition_id=first["composition_id"], expected_revision=1)
+    assert revised["revision"] == 2 and revised["item_state"] == "draft"
+    assert work._record(first["composition_id"])["item"]["approval"] is None
+    assert revised["publish_authorized"] is False
+
+
+def test_assets_are_immutable_hash_bound_and_cannot_escape_scope(workspace):
+    work, _ = workspace
+    source = work.project / "source.bin"
+    source.write_bytes(b"synthetic source")
+    asset = {"id": "source", "path": source.name, "sha256": hashlib.sha256(source.read_bytes()).hexdigest(),
+             "kind": "image", "source_ref": "synthetic:source", "visibility": "local_private"}
+    plan = {**brief(), "assets": [asset]}
+    prepared = work.prepare(plan, source_directory=work.project)
+    snapshot = Path(work._record(prepared["composition_id"])["sources"]["source"])
+    source.write_bytes(b"later source")
+    assert snapshot.read_bytes() == b"synthetic source"
+    with pytest.raises(ValueError, match="Source bytes changed"):
+        work.prepare(plan, source_directory=work.project)
+    (work.project / "link").symlink_to(source)
+    for path in ("../outside", "link"):
+        with pytest.raises((ValueError, EffectRuntimeRejected)):
+            work.prepare({**plan, "assets": [{**asset, "path": path}]}, source_directory=work.project)
+    with pytest.raises(ValueError, match="composition reference"):
+        work.inspect("../../outside")
+
+
+def test_missing_provider_preserves_prepared_work_without_starting_an_attempt(workspace):
+    work, _ = workspace
+    first = work.prepare(brief(), source_directory=work.project)
+    before = work._record(first["composition_id"])
+    result = work.render(first["composition_id"], expected_revision=1)
+    assert result["ok"] is False and result["status"] == "provider_unavailable"
+    assert work._record(first["composition_id"]) == before
+    assert work.list()["compositions"][0]["status"] == "prepared"
+
+
+def test_concurrent_retry_cancel_and_interruption_preserve_one_effect(workspace, monkeypatch):
+    work, _ = workspace
+    # This controlled effect tests the store race. The real renderer is exercised
+    # separately; the stub does not certify any video output.
+    class Binding:
+        binding = object()
+        def public_readiness(self): return {"status": "ready"}
+    monkeypatch.setattr(work, "binding", Binding)
+    started, release = threading.Event(), threading.Event()
+    calls = []
+    def effect(binding, *, request):
+        calls.append(request["attempt_directory"])
+        started.set()
+        assert release.wait(5)
+        raise ValueError("synthetic failure")
+    monkeypatch.setattr(media, "execute_extension_runtime_binding", effect)
+    first = work.prepare(brief(), source_directory=work.project)
+    ident = first["composition_id"]
+    work.render(ident, expected_revision=1, background=True)
+    assert started.wait(5)
+    assert work.render(ident, expected_revision=1)["status"] == "rendering"
+    assert work.cancel(ident, expected_revision=1)["status"] == "cancellation_requested"
+    assert work.inspect(ident)["status"] == "rendering", "cancellation is a request, not premature completion"
+    release.set()
+    for _ in range(100):
+        if work.inspect(ident)["status"] != "rendering": break
+        time.sleep(.02)
+    assert work.inspect(ident)["status"] == "cancelled" and len(calls) == 1
+    record = work._record(ident)
+    record.update(status="rendering", updated_at=(datetime.now(timezone.utc) - timedelta(minutes=4)).isoformat())
+    media._save(work._bundle(ident) / "record.json", record)
+    assert work.inspect(ident)["status"] == "interrupted"
+    assert work._record(ident)["status"] == "rendering", "inspection must not restart or mutate a render"
+    assert work.render(ident, expected_revision=1)["status"] == "failed"
+    assert len(calls) == 2
+
+
+@pytest.fixture
+def http_workspace(workspace):
+    work, registry = workspace
+    server = ChatHTTPServer(("127.0.0.1", 0), ChatRequestHandler)
+    server.registry_path, server.runtime_root = registry, work.runtime_root
+    server.selected_goal_id, server.verbose = "media-demo", False
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    def exchange(method, path, body=None, headers=None):
+        connection = http.client.HTTPConnection(*server.server_address, timeout=10)
+        connection.request(method, path, json.dumps(body).encode() if body is not None else None,
+            headers={"Origin": f"http://127.0.0.1:{server.server_address[1]}", "Content-Type": "application/json", **(headers or {})})
+        response = connection.getresponse()
+        result = response.status, dict(response.getheaders()), response.read()
+        connection.close()
+        return result
+    yield work, exchange
+    server.shutdown(); server.server_close(); thread.join(2)
+
+
+def test_real_http_admission_rejects_foreign_goal_origin_and_path_injection(http_workspace):
+    work, exchange = http_workspace
+    first = work.prepare(brief(), source_directory=work.project)
+    endpoint = "/api/chat/content-media"
+    status, _, body = exchange("POST", endpoint, {"goal_id": "media-demo", "action": "list"})
+    assert status == 200 and json.loads(body)["compositions"][0]["composition_id"] == first["composition_id"]
+    assert exchange("POST", endpoint, {"goal_id": "another-goal", "action": "list"})[0] == 400
+    assert exchange("POST", endpoint, {"goal_id": "media-demo", "action": "list", "source_directory": "outside"})[0] == 400
+    assert exchange("POST", endpoint, {"goal_id": "media-demo", "action": "list"}, {"Origin": "https://unrelated.example"})[0] == 403
+    assert exchange("GET", endpoint + "/file?goal_id=media-demo&composition_id=..&file=video.mp4")[0] == 404
+    assert b"source_directory" not in body and str(work.project).encode() not in body
+
+
+@pytest.mark.skipif(os.environ.get("LOOPX_MEDIA_RENDERER_TEST") != "1", reason="explicit optional local renderer qualification")
+def test_real_optional_renderer_reuse_and_http_byte_readback(http_workspace):
+    """No model calls: use the actual extension, encoder, store and HTTP route."""
+    import subprocess
+    import sys
+    from urllib.parse import urlencode
+    work, exchange = http_workspace
+    executable = shutil.which("loopx-media")
+    assert executable, "Install packages/loopx-media in an isolated environment and put its executable on PATH"
+    root = Path(__file__).resolve().parents[1]
+    command = [sys.executable, "-m", "loopx.cli", "--format", "json", "extension"]
+    state = work.runtime_root / "extensions/state.json"
+    installed = subprocess.run([*command, "install", "--manifest", str(root / "packages/loopx-media/extension.toml"), "--state-file", str(state), "--execute"], capture_output=True, text=True)
+    assert installed.returncode == 0, installed.stdout + installed.stderr
+    first = work.prepare(brief(), source_directory=work.project)
+    ident = first["composition_id"]
+    ready = work.render(ident, expected_revision=1)
+    assert ready["status"] == "ready", ready
+    assert ready["result"]["qa"]["frames"] == 36
+    record = work._record(ident)
+    before = record["attempt"]
+    assert work.render(ident, expected_revision=1)["status"] == "ready"
+    assert work._record(ident)["attempt"] == before
+    movie = work.file(ident, "video.mp4")
+    query = urlencode({"goal_id": "media-demo", "composition_id": ident, "file": "video.mp4"})
+    status, headers, data = exchange("GET", "/api/chat/content-media/file?" + query, headers={"Range": "bytes=0-31"})
+    assert status == 206 and data == movie.read_bytes()[:32] and headers["Cache-Control"] == "no-store"
+    assert headers["Content-Disposition"] == 'inline; filename="video.mp4"'
+    # A second brief reuses the installed provider with a real video source and
+    # supplied, explicitly synthetic audio rather than a new rendering script.
+    shutil.copyfile(movie, work.project / "source.mp4")
+    with wave.open(str(work.project / "voice.wav"), "wb") as wav:
+        wav.setnchannels(1); wav.setsampwidth(2); wav.setframerate(44100); wav.writeframes(b"\0\0" * 44100 * 3)
+    assets = [{"id": ident, "path": name, "kind": kind, "sha256": hashlib.sha256((work.project / name).read_bytes()).hexdigest(), "source_ref": "synthetic:" + ident, "visibility": "local_private"}
+              for ident, name, kind in [("movie", "source.mp4", "video"), ("voice", "voice.wav", "audio")]]
+    second = {**brief(), "title": "Review another brief", "assets": assets, "narration": {"mode": "supplied", "asset_id": "voice"},
+              "shots": [{"id": "view", "kind": "excerpt", "seconds": 3, "title": "Earlier synthetic render", "asset_id": "movie", "source_ref": "synthetic:movie", "boundary": "Synthetic excerpt; no live product run"}]}
+    prepared = work.prepare(second, source_directory=work.project)
+    rendered = work.render(prepared["composition_id"], expected_revision=1)
+    assert rendered["status"] == "ready" and rendered["result"]["qa"]["narration"]["mode"] == "supplied"
+    assert rendered["result"]["qa"]["narration"]["peak_dbfs"] is None
+    # Failed decode never produces a ready movie; a repaired revision recovers.
+    broken = deepcopy(second); broken["shots"][0]["start_seconds"] = 60
+    revised = work.prepare(broken, source_directory=work.project, composition_id=prepared["composition_id"], expected_revision=1)
+    assert work.render(revised["composition_id"], expected_revision=2)["status"] == "failed"
+    fixed = work.prepare(second, source_directory=work.project, composition_id=revised["composition_id"], expected_revision=2)
+    assert work.render(fixed["composition_id"], expected_revision=3)["status"] == "ready"
+    # A damaged artifact cannot be downloaded or silently treated as ready.
+    movie.write_bytes(b"damaged")
+    assert work.inspect(ident)["status"] == "damaged"
+    assert exchange("GET", "/api/chat/content-media/file?" + query)[0] == 404
+    disabled = subprocess.run([*command, "disable", "loopx-media", "--state-file", str(state), "--execute"], capture_output=True, text=True)
+    assert disabled.returncode == 0
+    assert work.render(ident, expected_revision=1)["status"] == "provider_unavailable"

From 6f2b4d9ff6869d0498b1eb851742c4be0dfe6b76 Mon Sep 17 00:00:00 2001
From: LoopX Agent <337587101+loopx-agent@users.noreply.github.com>
Date: Mon, 19 Oct 2026 13:00:45 +0800
Subject: [PATCH 2/9] fix(content-ops): inherit workbench theme and text tokens

Signed-off-by: LoopX Agent <337587101+loopx-agent@users.noreply.github.com>
---
 .../content-media-workbench.css               | 30 +++++++++----------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/apps/presentation/dashboard/src/features/personal-workspace/content-media-workbench.css b/apps/presentation/dashboard/src/features/personal-workspace/content-media-workbench.css
index 1d085b85f0..91ea290331 100644
--- a/apps/presentation/dashboard/src/features/personal-workspace/content-media-workbench.css
+++ b/apps/presentation/dashboard/src/features/personal-workspace/content-media-workbench.css
@@ -1,25 +1,25 @@
 .content-production-panel {padding:0 24px 24px;}
-.content-media {padding:16px 0 24px; border-bottom:1px solid var(--border, #e5e7eb);}
+.content-media {padding:16px 0 24px; border-bottom:1px solid var(--pw-line);}
 .content-media-heading, .content-media-title {display:flex; justify-content:space-between; align-items:flex-start; gap:16px;}
-.content-media h3, .content-media h4 {margin:0 0 6px; font-size:16px; font-weight:600;}
-.content-media p {margin:6px 0 14px; color:var(--muted-foreground, #666); font-size:13px; line-height:1.6;}
-.content-media button {min-height:44px; border:1px solid var(--border, #dce0e5); border-radius:7px; padding:8px 12px; background:var(--background, white); color:inherit; cursor:pointer; font:inherit; font-size:13px;}
+.content-media h3, .content-media h4 {margin:0 0 6px; font-size:var(--text-lead); font-weight:600;}
+.content-media p {margin:6px 0 14px; color:var(--pw-muted); font-size:var(--text-body); line-height:1.6;}
+.content-media button {min-height:44px; border:1px solid var(--pw-line-strong); border-radius:6px; padding:8px 12px; background:var(--pw-card); color:inherit; cursor:pointer; font:inherit; font-size:var(--text-body);}
 .content-media button:disabled {opacity:.5; cursor:default;}
-.content-media button:focus-visible, .content-media a:focus-visible {outline:2px solid var(--accent, #2768ea); outline-offset:3px;}
-.content-media-notice {padding:10px 12px; background:var(--muted, #f4f5f6); border-left:2px solid #8a95a5;}
+.content-media button:focus-visible, .content-media a:focus-visible {outline:2px solid var(--pw-blue); outline-offset:3px;}
+.content-media-notice {padding:10px 12px; background:var(--pw-hover); border-left:2px solid var(--pw-muted);}
 .content-media-workspace {display:grid; grid-template-columns:minmax(130px, 180px) minmax(0, 1fr); gap:20px; margin-top:20px;}
 .content-media nav {display:flex; flex-direction:column; gap:5px;}
 .content-media nav button {text-align:left; border-color:transparent; display:grid; gap:6px;}
-.content-media nav button[aria-pressed=true] {background:var(--muted, #f2f4f7); border-color:var(--border, #dce0e5);}
-.content-media small {display:block; color:var(--muted-foreground, #687080); font-size:11px; line-height:1.5;}
-.content-media-result {min-width:0;}
-.content-media-result video {display:block; width:100%; margin:14px 0; border-radius:8px; background:#f5f7fb;}
-.content-media-timeline {list-style:none; padding:0; margin:14px 0; border-top:1px solid var(--border, #e5e7eb);}
-.content-media-timeline li {padding:12px 0; border-bottom:1px solid var(--border, #e5e7eb); font-size:13px;}
+.content-media nav button[aria-pressed=true] {background:var(--pw-hover); border-color:var(--pw-line-strong);}
+.content-media small {display:block; color:var(--pw-muted); font-size:var(--text-caption); line-height:1.5;}
+.content-media-result {min-width:0; overflow-wrap:anywhere;}
+.content-media-result video {display:block; width:100%; margin:14px 0; border-radius:8px; background:var(--pw-card);}
+.content-media-timeline {list-style:none; padding:0; margin:14px 0; border-top:1px solid var(--pw-line);}
+.content-media-timeline li {padding:12px 0; border-bottom:1px solid var(--pw-line); font-size:var(--text-body);}
 .content-media-timeline small {margin-top:4px;}
-.content-media-downloads {display:flex; gap:16px; flex-wrap:wrap; font-size:13px;}
-.content-media details {font-size:12px; margin-top:18px;}
-.content-media details summary {cursor:pointer; color:var(--muted-foreground, #687080);}
+.content-media-downloads {display:flex; gap:16px; flex-wrap:wrap; font-size:var(--text-body);}
+.content-media details {font-size:var(--text-caption); margin-top:18px;}
+.content-media details summary {cursor:pointer; color:var(--pw-muted);}
 .content-media details li {line-height:1.6; margin:6px 0;}
 .content-media-empty {padding:22px 0;}
 @media(max-width:680px) {.content-production-panel {padding:0 16px 20px;}.content-media-workspace {grid-template-columns:minmax(0, 1fr);}.content-media nav {flex-direction:row; overflow-x:auto;}.content-media nav button {min-width:160px;}.content-media-heading, .content-media-title {flex-wrap:wrap;}}

From b9455b9119e1803feff0ce4904d4e125461424f6 Mon Sep 17 00:00:00 2001
From: LoopX Agent <337587101+loopx-agent@users.noreply.github.com>
Date: Mon, 19 Oct 2026 13:55:07 +0800
Subject: [PATCH 3/9] fix(content-ops): qualify media sources against CI lint

Signed-off-by: LoopX Agent <337587101+loopx-agent@users.noreply.github.com>
---
 loopx/presentation/content_media_api.py |  77 ++++--
 packages/loopx-media/README.md          |  15 +-
 tests/test_content_media.py             | 324 ++++++++++++++++++++----
 3 files changed, 343 insertions(+), 73 deletions(-)

diff --git a/loopx/presentation/content_media_api.py b/loopx/presentation/content_media_api.py
index 47a3615fca..f09a91b214 100644
--- a/loopx/presentation/content_media_api.py
+++ b/loopx/presentation/content_media_api.py
@@ -1,4 +1,5 @@
 """Loopback transport for Goal-owned private content compositions."""
+
 from __future__ import annotations
 
 import mimetypes
@@ -22,35 +23,62 @@ class ContentMediaRequestMixin:
     def _media_workspace(self, goal_id: str) -> MediaWorkspace:
         validate_goal_id(goal_id)
         selected = getattr(self.server, "selected_goal_id", None)
-        if selected and selected != goal_id: raise ValueError("Goal is outside this workspace")
+        if selected and selected != goal_id:
+            raise ValueError("Goal is outside this workspace")
         source = source_registry_for_goal(self.server.registry_path, goal_id)
-        return MediaWorkspace(registry_path=Path(source), goal_id=goal_id, runtime_root=Path(self.server.runtime_root))
+        return MediaWorkspace(
+            registry_path=Path(source),
+            goal_id=goal_id,
+            runtime_root=Path(self.server.runtime_root),
+        )
 
     def _content_media_request(self) -> None:
         try:
-            if urlparse(self.path).query: raise ValueError("Use the request body")
+            if urlparse(self.path).query:
+                raise ValueError("Use the request body")
             body = self._read_json(max_bytes=4096)
-            if set(body) - {"goal_id", "action", "composition_id", "expected_revision"}: raise ValueError("Unsupported fields")
+            if set(body) - {"goal_id", "action", "composition_id", "expected_revision"}:
+                raise ValueError("Unsupported fields")
             workspace = self._media_workspace(body["goal_id"])
             action = body["action"]
             if action == "list" and set(body) == {"goal_id", "action"}:
                 result = workspace.list()
-            elif action == "inspect" and set(body) == {"goal_id", "action", "composition_id"}:
+            elif action == "inspect" and set(body) == {
+                "goal_id",
+                "action",
+                "composition_id",
+            }:
                 result = workspace.inspect(body["composition_id"])
-            elif action in {"render", "cancel"} and set(body) == {"goal_id", "action", "composition_id", "expected_revision"}:
+            elif action in {"render", "cancel"} and set(body) == {
+                "goal_id",
+                "action",
+                "composition_id",
+                "expected_revision",
+            }:
                 revision = body["expected_revision"]
-                if isinstance(revision, bool) or not isinstance(revision, int): raise ValueError("Read the current revision")
+                if isinstance(revision, bool) or not isinstance(revision, int):
+                    raise ValueError("Read the current revision")
                 method = workspace.render if action == "render" else workspace.cancel
-                result = method(body["composition_id"], expected_revision=revision, **({"background": True} if action == "render" else {}))
-            else: raise ValueError("Unsupported operation")
+                result = method(
+                    body["composition_id"],
+                    expected_revision=revision,
+                    **({"background": True} if action == "render" else {}),
+                )
+            else:
+                raise ValueError("Unsupported operation")
             self._send_json(result)
         except (OSError, ValueError, TypeError, KeyError, RuntimeError):
-            self._send_error("Video request unavailable. Reopen the selected Goal and composition, then retry.", status=400)
+            self._send_error(
+                "Video request unavailable. Reopen the selected Goal and composition, then retry.",
+                status=400,
+            )
 
     def _content_media_file(self) -> None:
         try:
             query = parse_qs(urlparse(self.path).query, strict_parsing=True)
-            if set(query) != {"goal_id", "composition_id", "file"} or any(len(v) != 1 for v in query.values()):
+            if set(query) != {"goal_id", "composition_id", "file"} or any(
+                len(v) != 1 for v in query.values()
+            ):
                 raise ValueError("Invalid file request")
             workspace = self._media_workspace(query["goal_id"][0])
             name = query["file"][0]
@@ -62,26 +90,39 @@ def _content_media_file(self) -> None:
                 header = self.headers.get("Range")
                 if header:
                     match = re.fullmatch(r"bytes=(\d+)-(\d*)", header)
-                    if not match: raise ValueError("Unsupported byte range")
-                    start, end = int(match[1]), min(int(match[2]) if match[2] else size - 1, size - 1)
-                    if not 0 <= start <= end < size: raise ValueError("Invalid byte range")
+                    if not match:
+                        raise ValueError("Unsupported byte range")
+                    start, end = (
+                        int(match[1]),
+                        min(int(match[2]) if match[2] else size - 1, size - 1),
+                    )
+                    if not 0 <= start <= end < size:
+                        raise ValueError("Invalid byte range")
                     status = 206
                 self.send_response(status)
-                self.send_header("Content-Type", "text/vtt; charset=utf-8" if name.endswith(".vtt") else mimetypes.guess_type(name)[0] or "application/octet-stream")
+                self.send_header(
+                    "Content-Type",
+                    "text/vtt; charset=utf-8"
+                    if name.endswith(".vtt")
+                    else mimetypes.guess_type(name)[0] or "application/octet-stream",
+                )
                 self.send_header("Content-Length", str(end - start + 1))
                 self.send_header("Content-Disposition", f'inline; filename="{name}"')
                 self.send_header("Accept-Ranges", "bytes")
                 self.send_header("Cache-Control", "no-store")
                 self.send_header("Cross-Origin-Resource-Policy", "same-origin")
                 self.send_header("X-Content-Type-Options", "nosniff")
-                if status == 206: self.send_header("Content-Range", f"bytes {start}-{end}/{size}")
+                if status == 206:
+                    self.send_header("Content-Range", f"bytes {start}-{end}/{size}")
                 self.end_headers()
                 source.seek(start)
                 remaining = end - start + 1
                 while remaining:
                     chunk = source.read(min(remaining, 65536))
-                    if not chunk: break
-                    self.wfile.write(chunk); remaining -= len(chunk)
+                    if not chunk:
+                        break
+                    self.wfile.write(chunk)
+                    remaining -= len(chunk)
         except (BrokenPipeError, ConnectionResetError):
             return
         except (OSError, ValueError, TypeError, KeyError):
diff --git a/packages/loopx-media/README.md b/packages/loopx-media/README.md
index 66cfcebb92..f12f0e1a5e 100644
--- a/packages/loopx-media/README.md
+++ b/packages/loopx-media/README.md
@@ -77,9 +77,18 @@ does not delete them. There is no automatic cleanup of source evidence.
 
 ## Focused validation
 
-Core tests do not need this distribution. To exercise the actual optional
-extension, encoder, source reuse, recovery and HTTP byte serving after installing
-the executable in an isolated environment:
+Core tests do not need this distribution. For source changes, first run the
+repository-invariant and lint commands used by CI:
+
+```sh
+uv run --extra test python -m pytest -q --no-cov \
+  tests/test_stage2c_dependency_lock.py tests/architecture/test_top_level_module_budget.py
+uv run --extra test python -m ruff check \
+  tests loopx/canary loopx/control_plane loopx/domain_packs loopx/presentation
+```
+
+Then exercise the actual optional extension, encoder, source reuse, recovery
+and HTTP byte serving after installing the executable in an isolated environment:
 
 ```sh
 LOOPX_MEDIA_RENDERER_TEST=1 uv run --extra test pytest -q tests/test_content_media.py
diff --git a/tests/test_content_media.py b/tests/test_content_media.py
index 37d8d67b18..6606fa8c2e 100644
--- a/tests/test_content_media.py
+++ b/tests/test_content_media.py
@@ -1,4 +1,5 @@
 """Composition admission, optional effects and real loopback file boundaries."""
+
 from __future__ import annotations
 
 from copy import deepcopy
@@ -22,10 +23,33 @@
 
 
 def brief():
-    return {"schema_version": "content_ops_media_plan_v0", "title": "Return the result", "width": 640, "height": 360, "fps": 12,
-            "shots": [{"id": "flow", "kind": "diagram", "seconds": 3, "title": "A complete handoff", "nodes": ["Intent", "Owner", "Evidence"],
-                       "source_ref": "synthetic:handoff", "boundary": "Mechanism illustration"}],
-            "captions": [{"start": 0, "end": 3, "text": "Return evidence to the requester.", "language": "en"}], "narration": {"mode": "silent"}}
+    return {
+        "schema_version": "content_ops_media_plan_v0",
+        "title": "Return the result",
+        "width": 640,
+        "height": 360,
+        "fps": 12,
+        "shots": [
+            {
+                "id": "flow",
+                "kind": "diagram",
+                "seconds": 3,
+                "title": "A complete handoff",
+                "nodes": ["Intent", "Owner", "Evidence"],
+                "source_ref": "synthetic:handoff",
+                "boundary": "Mechanism illustration",
+            }
+        ],
+        "captions": [
+            {
+                "start": 0,
+                "end": 3,
+                "text": "Return evidence to the requester.",
+                "language": "en",
+            }
+        ],
+        "narration": {"mode": "silent"},
+    }
 
 
 @pytest.fixture
@@ -34,28 +58,74 @@ def workspace(tmp_path):
     project.mkdir()
     runtime = tmp_path / "runtime"
     registry = tmp_path / "registry.json"
-    registry.write_text(json.dumps({"schema_version": "0.1", "common_runtime_root": str(runtime),
-        "goals": [{"id": "media-demo", "repo": str(project), "status": "active"}]}))
-    return media.MediaWorkspace(registry_path=registry, goal_id="media-demo", runtime_root=runtime), registry
+    registry.write_text(
+        json.dumps(
+            {
+                "schema_version": "0.1",
+                "common_runtime_root": str(runtime),
+                "goals": [
+                    {"id": "media-demo", "repo": str(project), "status": "active"}
+                ],
+            }
+        )
+    )
+    return media.MediaWorkspace(
+        registry_path=registry, goal_id="media-demo", runtime_root=runtime
+    ), registry
 
 
 def test_prepare_is_replayable_and_revision_invalidates_publication_approval(workspace):
     work, _ = workspace
     first = work.prepare(brief(), source_directory=work.project)
-    same = work.prepare(brief(), source_directory=work.project, composition_id=first["composition_id"], expected_revision=1)
+    same = work.prepare(
+        brief(),
+        source_directory=work.project,
+        composition_id=first["composition_id"],
+        expected_revision=1,
+    )
     assert same["revision"] == 1
     assert first["provider"]["status"] != "ready"
     record = work._record(first["composition_id"])
     item = record["item"]
-    for action, payload in [("submit_review", {}), ("approve", {"approval_ref": "decision:owner", "content_digest": item["content_digest"], "revision": item["revision"], "effect_kind": "publish"})]:
-        item = apply_content_ops_item_event(item, {"event_id": action, "action": action, "payload": payload,
-            "expected_state": item["state"], "expected_revision": item["revision"], "occurred_at": media.now()})["item"]
+    for action, payload in [
+        ("submit_review", {}),
+        (
+            "approve",
+            {
+                "approval_ref": "decision:owner",
+                "content_digest": item["content_digest"],
+                "revision": item["revision"],
+                "effect_kind": "publish",
+            },
+        ),
+    ]:
+        item = apply_content_ops_item_event(
+            item,
+            {
+                "event_id": action,
+                "action": action,
+                "payload": payload,
+                "expected_state": item["state"],
+                "expected_revision": item["revision"],
+                "occurred_at": media.now(),
+            },
+        )["item"]
     record["item"] = item
     media._save(work._bundle(first["composition_id"]) / "record.json", record)
     changed = {**brief(), "title": "Revised claim"}
     with pytest.raises(ValueError, match="revision"):
-        work.prepare(changed, source_directory=work.project, composition_id=first["composition_id"], expected_revision=0)
-    revised = work.prepare(changed, source_directory=work.project, composition_id=first["composition_id"], expected_revision=1)
+        work.prepare(
+            changed,
+            source_directory=work.project,
+            composition_id=first["composition_id"],
+            expected_revision=0,
+        )
+    revised = work.prepare(
+        changed,
+        source_directory=work.project,
+        composition_id=first["composition_id"],
+        expected_revision=1,
+    )
     assert revised["revision"] == 2 and revised["item_state"] == "draft"
     assert work._record(first["composition_id"])["item"]["approval"] is None
     assert revised["publish_authorized"] is False
@@ -65,8 +135,14 @@ def test_assets_are_immutable_hash_bound_and_cannot_escape_scope(workspace):
     work, _ = workspace
     source = work.project / "source.bin"
     source.write_bytes(b"synthetic source")
-    asset = {"id": "source", "path": source.name, "sha256": hashlib.sha256(source.read_bytes()).hexdigest(),
-             "kind": "image", "source_ref": "synthetic:source", "visibility": "local_private"}
+    asset = {
+        "id": "source",
+        "path": source.name,
+        "sha256": hashlib.sha256(source.read_bytes()).hexdigest(),
+        "kind": "image",
+        "source_ref": "synthetic:source",
+        "visibility": "local_private",
+    }
     plan = {**brief(), "assets": [asset]}
     prepared = work.prepare(plan, source_directory=work.project)
     snapshot = Path(work._record(prepared["composition_id"])["sources"]["source"])
@@ -77,12 +153,17 @@ def test_assets_are_immutable_hash_bound_and_cannot_escape_scope(workspace):
     (work.project / "link").symlink_to(source)
     for path in ("../outside", "link"):
         with pytest.raises((ValueError, EffectRuntimeRejected)):
-            work.prepare({**plan, "assets": [{**asset, "path": path}]}, source_directory=work.project)
+            work.prepare(
+                {**plan, "assets": [{**asset, "path": path}]},
+                source_directory=work.project,
+            )
     with pytest.raises(ValueError, match="composition reference"):
         work.inspect("../../outside")
 
 
-def test_missing_provider_preserves_prepared_work_without_starting_an_attempt(workspace):
+def test_missing_provider_preserves_prepared_work_without_starting_an_attempt(
+    workspace,
+):
     work, _ = workspace
     first = work.prepare(brief(), source_directory=work.project)
     before = work._record(first["composition_id"])
@@ -92,21 +173,29 @@ def test_missing_provider_preserves_prepared_work_without_starting_an_attempt(wo
     assert work.list()["compositions"][0]["status"] == "prepared"
 
 
-def test_concurrent_retry_cancel_and_interruption_preserve_one_effect(workspace, monkeypatch):
+def test_concurrent_retry_cancel_and_interruption_preserve_one_effect(
+    workspace, monkeypatch
+):
     work, _ = workspace
+
     # This controlled effect tests the store race. The real renderer is exercised
     # separately; the stub does not certify any video output.
     class Binding:
         binding = object()
-        def public_readiness(self): return {"status": "ready"}
+
+        def public_readiness(self):
+            return {"status": "ready"}
+
     monkeypatch.setattr(work, "binding", Binding)
     started, release = threading.Event(), threading.Event()
     calls = []
+
     def effect(binding, *, request):
         calls.append(request["attempt_directory"])
         started.set()
         assert release.wait(5)
         raise ValueError("synthetic failure")
+
     monkeypatch.setattr(media, "execute_extension_runtime_binding", effect)
     first = work.prepare(brief(), source_directory=work.project)
     ident = first["composition_id"]
@@ -114,17 +203,25 @@ def effect(binding, *, request):
     assert started.wait(5)
     assert work.render(ident, expected_revision=1)["status"] == "rendering"
     assert work.cancel(ident, expected_revision=1)["status"] == "cancellation_requested"
-    assert work.inspect(ident)["status"] == "rendering", "cancellation is a request, not premature completion"
+    assert work.inspect(ident)["status"] == "rendering", (
+        "cancellation is a request, not premature completion"
+    )
     release.set()
     for _ in range(100):
-        if work.inspect(ident)["status"] != "rendering": break
-        time.sleep(.02)
+        if work.inspect(ident)["status"] != "rendering":
+            break
+        time.sleep(0.02)
     assert work.inspect(ident)["status"] == "cancelled" and len(calls) == 1
     record = work._record(ident)
-    record.update(status="rendering", updated_at=(datetime.now(timezone.utc) - timedelta(minutes=4)).isoformat())
+    record.update(
+        status="rendering",
+        updated_at=(datetime.now(timezone.utc) - timedelta(minutes=4)).isoformat(),
+    )
     media._save(work._bundle(ident) / "record.json", record)
     assert work.inspect(ident)["status"] == "interrupted"
-    assert work._record(ident)["status"] == "rendering", "inspection must not restart or mutate a render"
+    assert work._record(ident)["status"] == "rendering", (
+        "inspection must not restart or mutate a render"
+    )
     assert work.render(ident, expected_revision=1)["status"] == "failed"
     assert len(calls) == 2
 
@@ -137,44 +234,106 @@ def http_workspace(workspace):
     server.selected_goal_id, server.verbose = "media-demo", False
     thread = threading.Thread(target=server.serve_forever, daemon=True)
     thread.start()
+
     def exchange(method, path, body=None, headers=None):
         connection = http.client.HTTPConnection(*server.server_address, timeout=10)
-        connection.request(method, path, json.dumps(body).encode() if body is not None else None,
-            headers={"Origin": f"http://127.0.0.1:{server.server_address[1]}", "Content-Type": "application/json", **(headers or {})})
+        connection.request(
+            method,
+            path,
+            json.dumps(body).encode() if body is not None else None,
+            headers={
+                "Origin": f"http://127.0.0.1:{server.server_address[1]}",
+                "Content-Type": "application/json",
+                **(headers or {}),
+            },
+        )
         response = connection.getresponse()
         result = response.status, dict(response.getheaders()), response.read()
         connection.close()
         return result
+
     yield work, exchange
-    server.shutdown(); server.server_close(); thread.join(2)
+    server.shutdown()
+    server.server_close()
+    thread.join(2)
 
 
-def test_real_http_admission_rejects_foreign_goal_origin_and_path_injection(http_workspace):
+def test_real_http_admission_rejects_foreign_goal_origin_and_path_injection(
+    http_workspace,
+):
     work, exchange = http_workspace
     first = work.prepare(brief(), source_directory=work.project)
     endpoint = "/api/chat/content-media"
-    status, _, body = exchange("POST", endpoint, {"goal_id": "media-demo", "action": "list"})
-    assert status == 200 and json.loads(body)["compositions"][0]["composition_id"] == first["composition_id"]
-    assert exchange("POST", endpoint, {"goal_id": "another-goal", "action": "list"})[0] == 400
-    assert exchange("POST", endpoint, {"goal_id": "media-demo", "action": "list", "source_directory": "outside"})[0] == 400
-    assert exchange("POST", endpoint, {"goal_id": "media-demo", "action": "list"}, {"Origin": "https://unrelated.example"})[0] == 403
-    assert exchange("GET", endpoint + "/file?goal_id=media-demo&composition_id=..&file=video.mp4")[0] == 404
+    status, _, body = exchange(
+        "POST", endpoint, {"goal_id": "media-demo", "action": "list"}
+    )
+    assert (
+        status == 200
+        and json.loads(body)["compositions"][0]["composition_id"]
+        == first["composition_id"]
+    )
+    assert (
+        exchange("POST", endpoint, {"goal_id": "another-goal", "action": "list"})[0]
+        == 400
+    )
+    assert (
+        exchange(
+            "POST",
+            endpoint,
+            {"goal_id": "media-demo", "action": "list", "source_directory": "outside"},
+        )[0]
+        == 400
+    )
+    assert (
+        exchange(
+            "POST",
+            endpoint,
+            {"goal_id": "media-demo", "action": "list"},
+            {"Origin": "https://unrelated.example"},
+        )[0]
+        == 403
+    )
+    assert (
+        exchange(
+            "GET",
+            endpoint + "/file?goal_id=media-demo&composition_id=..&file=video.mp4",
+        )[0]
+        == 404
+    )
     assert b"source_directory" not in body and str(work.project).encode() not in body
 
 
-@pytest.mark.skipif(os.environ.get("LOOPX_MEDIA_RENDERER_TEST") != "1", reason="explicit optional local renderer qualification")
+@pytest.mark.skipif(
+    os.environ.get("LOOPX_MEDIA_RENDERER_TEST") != "1",
+    reason="explicit optional local renderer qualification",
+)
 def test_real_optional_renderer_reuse_and_http_byte_readback(http_workspace):
     """No model calls: use the actual extension, encoder, store and HTTP route."""
     import subprocess
     import sys
     from urllib.parse import urlencode
+
     work, exchange = http_workspace
     executable = shutil.which("loopx-media")
-    assert executable, "Install packages/loopx-media in an isolated environment and put its executable on PATH"
+    assert executable, (
+        "Install packages/loopx-media in an isolated environment and put its executable on PATH"
+    )
     root = Path(__file__).resolve().parents[1]
     command = [sys.executable, "-m", "loopx.cli", "--format", "json", "extension"]
     state = work.runtime_root / "extensions/state.json"
-    installed = subprocess.run([*command, "install", "--manifest", str(root / "packages/loopx-media/extension.toml"), "--state-file", str(state), "--execute"], capture_output=True, text=True)
+    installed = subprocess.run(
+        [
+            *command,
+            "install",
+            "--manifest",
+            str(root / "packages/loopx-media/extension.toml"),
+            "--state-file",
+            str(state),
+            "--execute",
+        ],
+        capture_output=True,
+        text=True,
+    )
     assert installed.returncode == 0, installed.stdout + installed.stderr
     first = work.prepare(brief(), source_directory=work.project)
     ident = first["composition_id"]
@@ -186,33 +345,94 @@ def test_real_optional_renderer_reuse_and_http_byte_readback(http_workspace):
     assert work.render(ident, expected_revision=1)["status"] == "ready"
     assert work._record(ident)["attempt"] == before
     movie = work.file(ident, "video.mp4")
-    query = urlencode({"goal_id": "media-demo", "composition_id": ident, "file": "video.mp4"})
-    status, headers, data = exchange("GET", "/api/chat/content-media/file?" + query, headers={"Range": "bytes=0-31"})
-    assert status == 206 and data == movie.read_bytes()[:32] and headers["Cache-Control"] == "no-store"
+    query = urlencode(
+        {"goal_id": "media-demo", "composition_id": ident, "file": "video.mp4"}
+    )
+    status, headers, data = exchange(
+        "GET", "/api/chat/content-media/file?" + query, headers={"Range": "bytes=0-31"}
+    )
+    assert (
+        status == 206
+        and data == movie.read_bytes()[:32]
+        and headers["Cache-Control"] == "no-store"
+    )
     assert headers["Content-Disposition"] == 'inline; filename="video.mp4"'
     # A second brief reuses the installed provider with a real video source and
     # supplied, explicitly synthetic audio rather than a new rendering script.
     shutil.copyfile(movie, work.project / "source.mp4")
     with wave.open(str(work.project / "voice.wav"), "wb") as wav:
-        wav.setnchannels(1); wav.setsampwidth(2); wav.setframerate(44100); wav.writeframes(b"\0\0" * 44100 * 3)
-    assets = [{"id": ident, "path": name, "kind": kind, "sha256": hashlib.sha256((work.project / name).read_bytes()).hexdigest(), "source_ref": "synthetic:" + ident, "visibility": "local_private"}
-              for ident, name, kind in [("movie", "source.mp4", "video"), ("voice", "voice.wav", "audio")]]
-    second = {**brief(), "title": "Review another brief", "assets": assets, "narration": {"mode": "supplied", "asset_id": "voice"},
-              "shots": [{"id": "view", "kind": "excerpt", "seconds": 3, "title": "Earlier synthetic render", "asset_id": "movie", "source_ref": "synthetic:movie", "boundary": "Synthetic excerpt; no live product run"}]}
+        wav.setnchannels(1)
+        wav.setsampwidth(2)
+        wav.setframerate(44100)
+        wav.writeframes(b"\0\0" * 44100 * 3)
+    assets = [
+        {
+            "id": ident,
+            "path": name,
+            "kind": kind,
+            "sha256": hashlib.sha256((work.project / name).read_bytes()).hexdigest(),
+            "source_ref": "synthetic:" + ident,
+            "visibility": "local_private",
+        }
+        for ident, name, kind in [
+            ("movie", "source.mp4", "video"),
+            ("voice", "voice.wav", "audio"),
+        ]
+    ]
+    second = {
+        **brief(),
+        "title": "Review another brief",
+        "assets": assets,
+        "narration": {"mode": "supplied", "asset_id": "voice"},
+        "shots": [
+            {
+                "id": "view",
+                "kind": "excerpt",
+                "seconds": 3,
+                "title": "Earlier synthetic render",
+                "asset_id": "movie",
+                "source_ref": "synthetic:movie",
+                "boundary": "Synthetic excerpt; no live product run",
+            }
+        ],
+    }
     prepared = work.prepare(second, source_directory=work.project)
     rendered = work.render(prepared["composition_id"], expected_revision=1)
-    assert rendered["status"] == "ready" and rendered["result"]["qa"]["narration"]["mode"] == "supplied"
+    assert (
+        rendered["status"] == "ready"
+        and rendered["result"]["qa"]["narration"]["mode"] == "supplied"
+    )
     assert rendered["result"]["qa"]["narration"]["peak_dbfs"] is None
     # Failed decode never produces a ready movie; a repaired revision recovers.
-    broken = deepcopy(second); broken["shots"][0]["start_seconds"] = 60
-    revised = work.prepare(broken, source_directory=work.project, composition_id=prepared["composition_id"], expected_revision=1)
-    assert work.render(revised["composition_id"], expected_revision=2)["status"] == "failed"
-    fixed = work.prepare(second, source_directory=work.project, composition_id=revised["composition_id"], expected_revision=2)
-    assert work.render(fixed["composition_id"], expected_revision=3)["status"] == "ready"
+    broken = deepcopy(second)
+    broken["shots"][0]["start_seconds"] = 60
+    revised = work.prepare(
+        broken,
+        source_directory=work.project,
+        composition_id=prepared["composition_id"],
+        expected_revision=1,
+    )
+    assert (
+        work.render(revised["composition_id"], expected_revision=2)["status"]
+        == "failed"
+    )
+    fixed = work.prepare(
+        second,
+        source_directory=work.project,
+        composition_id=revised["composition_id"],
+        expected_revision=2,
+    )
+    assert (
+        work.render(fixed["composition_id"], expected_revision=3)["status"] == "ready"
+    )
     # A damaged artifact cannot be downloaded or silently treated as ready.
     movie.write_bytes(b"damaged")
     assert work.inspect(ident)["status"] == "damaged"
     assert exchange("GET", "/api/chat/content-media/file?" + query)[0] == 404
-    disabled = subprocess.run([*command, "disable", "loopx-media", "--state-file", str(state), "--execute"], capture_output=True, text=True)
+    disabled = subprocess.run(
+        [*command, "disable", "loopx-media", "--state-file", str(state), "--execute"],
+        capture_output=True,
+        text=True,
+    )
     assert disabled.returncode == 0
     assert work.render(ident, expected_revision=1)["status"] == "provider_unavailable"

From b08cf3fc61fb73d3a91609ea2abd73f4239b5b31 Mon Sep 17 00:00:00 2001
From: LoopX Agent <337587101+loopx-agent@users.noreply.github.com>
Date: Mon, 19 Oct 2026 14:19:59 +0800
Subject: [PATCH 4/9] fix(content-ops): reuse digest owner and qualify
 capability catalog

Signed-off-by: LoopX Agent <337587101+loopx-agent@users.noreply.github.com>
---
 examples/personal-workspace-browser/typed-actions.mjs      | 2 +-
 loopx/control_plane/capabilities/content_media.ts          | 5 +++--
 tests/control_plane_ts/content_digest_single_owner.test.ts | 1 +
 3 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/examples/personal-workspace-browser/typed-actions.mjs b/examples/personal-workspace-browser/typed-actions.mjs
index 7b185951f9..b8b630dfd4 100644
--- a/examples/personal-workspace-browser/typed-actions.mjs
+++ b/examples/personal-workspace-browser/typed-actions.mjs
@@ -1082,7 +1082,7 @@ export const typedActionsScenario = {
       const expectedGoalCapabilities = [
         "变更质量验证", "Goal 复盘与步幅", "探索图谱", "探索 Harness", "飞书事件收件箱",
         "飞书看板心跳同步", "已退役的 Authority 观测", "自适应子 Agent 容量",
-        "已注册 Peer 任务协调", "周期报告", "记忆与资料",
+        "已注册 Peer 任务协调", "周期报告", "记忆与资料", "内容制作",
       ];
       if (JSON.stringify([...goalCapabilityOrder].sort()) !== JSON.stringify(expectedGoalCapabilities.sort())) {
         throw new Error(`Goal capability workbench did not render the complete catalog: ${JSON.stringify(goalCapabilityOrder)}`);
diff --git a/loopx/control_plane/capabilities/content_media.ts b/loopx/control_plane/capabilities/content_media.ts
index 7b3364f7da..ce47ee20c9 100644
--- a/loopx/control_plane/capabilities/content_media.ts
+++ b/loopx/control_plane/capabilities/content_media.ts
@@ -2,6 +2,7 @@
  * These render states are local to a composition, never publication approvals.
  */
 import {createHash} from "node:crypto";
+import {BARE_SHA256_PATTERN} from "../content_digest.ts";
 import {EffectRuntimeRequestError} from "../effect_runtime_errors.ts";
 import layouts from "../../capabilities/content_ops/templates/layout-catalog-v0.json" with {type: "json"};
 
@@ -52,7 +53,7 @@ export function validateMediaPlan(input: unknown) {
     fields(asset, ["id", "path", "sha256", "kind", "source_ref", "visibility"]);
     const path = text(asset.path, 400);
     if (path.startsWith("/") || path.includes("\\") || path.split("/").some(part => part === ".." || !part || part === ".")) fail("Assets must be relative files inside the explicit source directory");
-    if (typeof asset.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(asset.sha256)) fail("Each source requires its exact SHA256");
+    if (typeof asset.sha256 !== "string" || !BARE_SHA256_PATTERN.test(asset.sha256)) fail("Each source requires its exact SHA256");
     if (typeof asset.kind !== "string" || !["image", "video", "audio"].includes(asset.kind)) fail("Unsupported asset kind");
     if (typeof asset.visibility !== "string" || !["local_private", "public_safe"].includes(asset.visibility)) fail("Each source requires its visibility boundary");
     return {id: token(asset.id), path, sha256: asset.sha256, kind: asset.kind as string,
@@ -124,7 +125,7 @@ export function validateMediaResult(input: unknown) {
   for (const [name, raw] of Object.entries(entries)) {
     if (!allowed.includes(name)) fail("Unexpected renderer file");
     const entry = object(raw);
-    if (typeof entry.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(entry.sha256)) fail("Invalid renderer digest");
+    if (typeof entry.sha256 !== "string" || !BARE_SHA256_PATTERN.test(entry.sha256)) fail("Invalid renderer digest");
     files[name] = {sha256: entry.sha256, bytes: number(entry.bytes, 0, 128 * 1024 * 1024, true)};
   }
   if (["video.mp4", "poster.png", "captions.vtt", "captions.srt", "transcript.txt"].some(name => !files[name])) fail("Renderer output incomplete");
diff --git a/tests/control_plane_ts/content_digest_single_owner.test.ts b/tests/control_plane_ts/content_digest_single_owner.test.ts
index 8a683c4c3c..1738cba52f 100644
--- a/tests/control_plane_ts/content_digest_single_owner.test.ts
+++ b/tests/control_plane_ts/content_digest_single_owner.test.ts
@@ -92,6 +92,7 @@ const DECLARED_UNFOLDABLE: Record<string, { count: number; reason: string }> = {
 const CANONICAL_CONSUMERS = [
   "control_plane/agents/supervisor_event_append.ts",
   "control_plane/capabilities/change_quality_validation.ts",
+  "control_plane/capabilities/content_media.ts",
   "control_plane/capabilities/explore_result_page.ts",
   "control_plane/capabilities/external_evidence.ts",
   "control_plane/capabilities/goal_capability_organization.ts",

From b915abce14f7c3ebcf012f6e4721add9c2e6961e Mon Sep 17 00:00:00 2001
From: LoopX Agent <337587101+loopx-agent@users.noreply.github.com>
Date: Mon, 19 Oct 2026 14:29:09 +0800
Subject: [PATCH 5/9] test(content-ops): preserve the two memory purpose owners

Signed-off-by: LoopX Agent <337587101+loopx-agent@users.noreply.github.com>
---
 examples/personal-workspace-browser/typed-actions.mjs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/examples/personal-workspace-browser/typed-actions.mjs b/examples/personal-workspace-browser/typed-actions.mjs
index b8b630dfd4..0677cb9dcb 100644
--- a/examples/personal-workspace-browser/typed-actions.mjs
+++ b/examples/personal-workspace-browser/typed-actions.mjs
@@ -1098,8 +1098,8 @@ export const typedActionsScenario = {
       await page.locator(".personal-capability-list").getByRole("button", {name:"记忆与资料",exact:true}).click();
       await page.getByRole("heading", {level:2,name:"记忆与资料",exact:true}).waitFor({state:"visible"});
       const memoryTabs = page.getByRole("tablist", {name:"记忆用途"});
-      if (JSON.stringify(await memoryTabs.getByRole("tab").allTextContents()) !== JSON.stringify(["资料召回", "经验学习", "素材与风格"])) {
-        throw new Error("Memory navigation must expose the registered purposes inside one entry");
+      if (JSON.stringify(await memoryTabs.getByRole("tab").allTextContents()) !== JSON.stringify(["资料召回", "经验学习"])) {
+        throw new Error("Memory navigation must retain evidence and experience purposes; reference styles belong to Content production");
       }
       await page.getByRole("tab", {name:"资料召回",exact:true}).focus();
       await page.keyboard.press("ArrowRight");

From 01e50b1fcbd1f552d7c5fea164208ddc45d9dd28 Mon Sep 17 00:00:00 2001
From: LoopX Agent <337587101+loopx-agent@users.noreply.github.com>
Date: Mon, 19 Oct 2026 14:56:53 +0800
Subject: [PATCH 6/9] fix(content-ops): refuse lossy captions and verify
 subtitle consumers

Signed-off-by: LoopX Agent <337587101+loopx-agent@users.noreply.github.com>
---
 .../protocols/content-ops-media-v0.md         |  9 +++
 .../capabilities/content_media.ts             |  2 +
 packages/loopx-media/README.md                | 14 ++++-
 .../loopx-media/src/loopx_media/renderer.py   |  8 ++-
 tests/control_plane_ts/content_media.test.ts  | 12 ++++
 tests/test_content_media.py                   | 56 ++++++++++++++++++-
 6 files changed, 98 insertions(+), 3 deletions(-)

diff --git a/docs/reference/protocols/content-ops-media-v0.md b/docs/reference/protocols/content-ops-media-v0.md
index 259cfbcba4..743bde6fc7 100644
--- a/docs/reference/protocols/content-ops-media-v0.md
+++ b/docs/reference/protocols/content-ops-media-v0.md
@@ -27,6 +27,15 @@ request to an Agent but does not gain an independent renderer or upload action.
 | `captions` | Ordered nonoverlapping `start`, `end`, `text`, `language` cues inside the composition. One sequential caption track is emitted. |
 | `narration` | Explicit `silent`, `supplied` with audio `asset_id`, or `system_speech` with installed `voice` and optional words-per-minute. |
 
+Caption text is plain text. Single line breaks are supported; an internal
+blank line is refused before preparation because it terminates a subtitle
+cue. Use single line breaks or separate timed cues instead. Angle brackets
+and entity syntax (such as `&lt;` or `&#60;`) are also refused: literal markup
+and entity preservation is not qualified for this SubRip export. Write spoken plain text instead. The
+renderer repeats these format checks, escapes ordinary ampersands in VTT,
+and preserves plain text in SRT and the transcript. This bounded subset is
+qualified with the native browser track and real FFmpeg subtitle decoding.
+
 Shots are `title`, `diagram` (two to five `nodes`) or `excerpt` (image/video
 `asset_id` and optional `start_seconds`). These are composition-local rendering
 choices. They do not extend Goal/Todo state. Likewise prepared/rendering/ready/
diff --git a/loopx/control_plane/capabilities/content_media.ts b/loopx/control_plane/capabilities/content_media.ts
index ce47ee20c9..5e556f47da 100644
--- a/loopx/control_plane/capabilities/content_media.ts
+++ b/loopx/control_plane/capabilities/content_media.ts
@@ -91,6 +91,8 @@ export function validateMediaPlan(input: unknown) {
     if (!/^[a-z]{2}(?:-[A-Z]{2})?$/.test(language)) fail("Invalid caption language");
     const content = text(cue.text, 220);
     if (content.includes("-->")) fail("Invalid caption delimiter");
+    if (/\n[\t ]*\n/.test(content)) fail("Caption blank lines are unsupported; use single line breaks or separate timed cues");
+    if (/[<>]|&(?:[a-zA-Z]+|#\d+|#x[0-9a-fA-F]+);/.test(content)) fail("Caption markup and entity syntax are unsupported; write spoken plain text instead");
     end = stop;
     return {start, end: stop, text: content, language};
   });
diff --git a/packages/loopx-media/README.md b/packages/loopx-media/README.md
index f12f0e1a5e..291d806de9 100644
--- a/packages/loopx-media/README.md
+++ b/packages/loopx-media/README.md
@@ -48,6 +48,13 @@ in place and read back after the worker stops; a host interruption is recovered
 by an explicit retry. An intact completed result is reused without encoding
 again. Damaged result bytes cannot be downloaded as verified output.
 
+Captions use a bounded plain-text subset. Single line breaks, ordinary
+ampersands and quotes work. Internal blank lines delimit subtitle cues;
+angle brackets and entity syntax are not supported by this SubRip export.
+These inputs are refused before preparation and by the renderer. Use separate
+timed cues for paragraphs and spell out markup or comparisons rather than
+producing a subtitle file that silently loses or reinterprets accepted text.
+
 ## Bounds and review
 
 Plans are limited to 90 seconds, 30 shots, 20 local assets and 80 ordered
@@ -91,9 +98,14 @@ Then exercise the actual optional extension, encoder, source reuse, recovery
 and HTTP byte serving after installing the executable in an isolated environment:
 
 ```sh
-LOOPX_MEDIA_RENDERER_TEST=1 uv run --extra test pytest -q tests/test_content_media.py
+LOOPX_MEDIA_RENDERER_TEST=1 uv run --extra test --with-editable ./packages/loopx-media \
+  python -m pytest -q tests/test_content_media.py
 node --test tests/control_plane_ts/content_media.test.ts
 ```
 
 The opt-in test uses synthetic local sources and no model or cloud service.
+Its optional package dependency supplies the real FFmpeg subtitle consumer;
+decoded VTT/SRT text must preserve accepted line breaks, ampersands and quotes.
+The source qualification checks the editable module and executable environment
+so a cached wheel cannot silently stand in for the source under review.
 It is integration evidence, not a subjective or comparative creative study.
diff --git a/packages/loopx-media/src/loopx_media/renderer.py b/packages/loopx-media/src/loopx_media/renderer.py
index 5e6d2c6618..87fff7e228 100644
--- a/packages/loopx-media/src/loopx_media/renderer.py
+++ b/packages/loopx-media/src/loopx_media/renderer.py
@@ -7,6 +7,7 @@
 from __future__ import annotations
 
 import hashlib
+from html import escape
 import json
 import os
 from pathlib import Path
@@ -64,7 +65,12 @@ def stamp(seconds: float, *, srt: bool = False) -> str:
 def captions(plan: dict, out: Path) -> None:
     vtt, srt, transcript = ["WEBVTT\n"], [], [plan["title"]]
     for i, cue in enumerate(plan["captions"], 1):
-        vtt.append(f"{i}\n{stamp(cue['start'])} --> {stamp(cue['end'])}\n{cue['text']}\n")
+        if re.search(r"\n[\t ]*\n", cue["text"]):
+            raise ValueError("Caption blank lines cannot be serialized as one cue")
+        if re.search(r"[<>]|&(?:[a-zA-Z]+|#\d+|#x[0-9a-fA-F]+);", cue["text"]):
+            raise ValueError("Caption markup has no unambiguous plain SubRip representation")
+        payload = escape(cue["text"], quote=False)
+        vtt.append(f"{i}\n{stamp(cue['start'])} --> {stamp(cue['end'])}\n{payload}\n")
         srt.append(f"{i}\n{stamp(cue['start'], srt=True)} --> {stamp(cue['end'], srt=True)}\n{cue['text']}\n")
         transcript.append(f"{cue['start']:g}–{cue['end']:g}s · {cue['text']}")
     for filename, lines in (("captions.vtt", vtt), ("captions.srt", srt), ("transcript.txt", transcript)):
diff --git a/tests/control_plane_ts/content_media.test.ts b/tests/control_plane_ts/content_media.test.ts
index 183fc929cd..d9fcf574d7 100644
--- a/tests/control_plane_ts/content_media.test.ts
+++ b/tests/control_plane_ts/content_media.test.ts
@@ -69,3 +69,15 @@ test("render transitions are revision-bound and separate from publication", () =
   assert.throws(() => transition({state, expected_revision: 2, action: "success", observed_at: "now"}), /unavailable/);
   assert.throws(() => transition({state: running, expected_revision: 2, action: "publish", observed_at: "now"}));
 });
+
+test("caption admission preserves plain text and refuses structural paragraph separators", () => {
+  const caption = (text: string) => ({...brief(), captions: [{start: 0, end: 6, text, language: "en"}]});
+  const plain = "x & y\nQuoted \"literal\" text";
+  assert.equal(plan({plan: caption(plain)}).plan.captions[0]?.text, plain);
+  for (const text of ["FIRST LINE\n\nSECOND LINE", "FIRST LINE\n \t\nSECOND LINE"]) {
+    assert.throws(() => plan({plan: caption(text)}), /blank lines/);
+  }
+  for (const text of ["x < y", "x > y", "<b>literal</b>", "&lt;literal&gt;", "&#60;", "&#x3c;"]) {
+    assert.throws(() => plan({plan: caption(text)}), /markup and entity/);
+  }
+});
diff --git a/tests/test_content_media.py b/tests/test_content_media.py
index 6606fa8c2e..e7c036ec9e 100644
--- a/tests/test_content_media.py
+++ b/tests/test_content_media.py
@@ -161,6 +161,22 @@ def test_assets_are_immutable_hash_bound_and_cannot_escape_scope(workspace):
         work.inspect("../../outside")
 
 
+def test_unsupported_caption_refusal_does_not_create_a_prepared_composition(workspace):
+    work, _ = workspace
+    for text in (
+        "FIRST LINE\n\nSECOND LINE",
+        "FIRST LINE\n \t\nSECOND LINE",
+        "x < y",
+        "<b>literal</b>",
+        "&lt;literal&gt;",
+    ):
+        plan = brief()
+        plan["captions"][0]["text"] = text
+        with pytest.raises(EffectRuntimeRejected, match="Caption"):
+            work.prepare(plan, source_directory=work.project)
+    assert work.list()["compositions"] == []
+
+
 def test_missing_provider_preserves_prepared_work_without_starting_an_attempt(
     workspace,
 ):
@@ -313,12 +329,22 @@ def test_real_optional_renderer_reuse_and_http_byte_readback(http_workspace):
     import sys
     from urllib.parse import urlencode
 
+    import imageio_ffmpeg
+    import loopx_media.renderer as renderer
+
     work, exchange = http_workspace
     executable = shutil.which("loopx-media")
     assert executable, (
         "Install packages/loopx-media in an isolated environment and put its executable on PATH"
     )
     root = Path(__file__).resolve().parents[1]
+    assert (
+        Path(renderer.__file__).resolve()
+        == root / "packages/loopx-media/src/loopx_media/renderer.py"
+    ), "Run source qualification with --with-editable ./packages/loopx-media"
+    assert Path(executable).parent == Path(sys.executable).parent, (
+        "Use the optional provider from the qualification interpreter's environment"
+    )
     command = [sys.executable, "-m", "loopx.cli", "--format", "json", "extension"]
     state = work.runtime_root / "extensions/state.json"
     installed = subprocess.run(
@@ -335,7 +361,10 @@ def test_real_optional_renderer_reuse_and_http_byte_readback(http_workspace):
         text=True,
     )
     assert installed.returncode == 0, installed.stdout + installed.stderr
-    first = work.prepare(brief(), source_directory=work.project)
+    first_plan = brief()
+    caption_text = 'FIRST & SECOND "quoted"\nReturn evidence; preserve both lines.'
+    first_plan["captions"][0]["text"] = caption_text
+    first = work.prepare(first_plan, source_directory=work.project)
     ident = first["composition_id"]
     ready = work.render(ident, expected_revision=1)
     assert ready["status"] == "ready", ready
@@ -357,6 +386,31 @@ def test_real_optional_renderer_reuse_and_http_byte_readback(http_workspace):
         and headers["Cache-Control"] == "no-store"
     )
     assert headers["Content-Disposition"] == 'inline; filename="video.mp4"'
+    # Decode both actual subtitle containers through FFmpeg, independently of
+    # the writer. ASS represents the visible newline as \N; ordinary ampersands
+    # and quotes must round-trip without becoming escaped display text.
+    for name in ("captions.vtt", "captions.srt"):
+        decoded = subprocess.run(
+            [
+                imageio_ffmpeg.get_ffmpeg_exe(),
+                "-v",
+                "error",
+                "-i",
+                str(work.file(ident, name)),
+                "-f",
+                "ass",
+                "-",
+            ],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        payloads = [
+            line.split(",", 9)[9]
+            for line in decoded.stdout.splitlines()
+            if line.startswith("Dialogue:")
+        ]
+        assert payloads == [caption_text.replace("\n", r"\N")]
     # A second brief reuses the installed provider with a real video source and
     # supplied, explicitly synthetic audio rather than a new rendering script.
     shutil.copyfile(movie, work.project / "source.mp4")

From d613c8c4ef9ae7d7eae78b9fb154a89dad098324 Mon Sep 17 00:00:00 2001
From: LoopX Agent <337587101+loopx-agent@users.noreply.github.com>
Date: Mon, 19 Oct 2026 16:43:16 +0800
Subject: [PATCH 7/9] feat(content-ops): render editable Blender scenes through
 media compositions

Signed-off-by: LoopX Agent <337587101+loopx-agent@users.noreply.github.com>
---
 .../content-media-workbench.tsx               |  10 +-
 .../protocols/content-ops-media-v0.md         |  39 +-
 loopx/capabilities/content_ops/media.py       |   6 +-
 .../capabilities/content_media.ts             |  74 +++-
 packages/loopx-media/README.md                |  73 +++-
 .../loopx-media/examples/blender-handoff.json |  58 +++
 packages/loopx-media/extension.toml           |   2 +-
 packages/loopx-media/pyproject.toml           |   5 +-
 .../loopx-media/src/loopx_media/blender.py    | 362 ++++++++++++++++++
 .../loopx-media/src/loopx_media/renderer.py   |  23 +-
 tests/control_plane_ts/content_media.test.ts  |  52 +++
 tests/test_content_media.py                   | 150 +++++++-
 12 files changed, 828 insertions(+), 26 deletions(-)
 create mode 100644 packages/loopx-media/examples/blender-handoff.json
 create mode 100644 packages/loopx-media/src/loopx_media/blender.py

diff --git a/apps/presentation/dashboard/src/features/personal-workspace/content-media-workbench.tsx b/apps/presentation/dashboard/src/features/personal-workspace/content-media-workbench.tsx
index 8b6e1c7405..3b83635b3c 100644
--- a/apps/presentation/dashboard/src/features/personal-workspace/content-media-workbench.tsx
+++ b/apps/presentation/dashboard/src/features/personal-workspace/content-media-workbench.tsx
@@ -6,7 +6,7 @@ type Provider = {status: string; enabled: boolean | null; next_action: string |
 type Composition = {
   composition_id: string; revision: number; status: string; title: string; duration_seconds: number;
   shots: {title: string; seconds: number; kind: string; boundary: string; source_ref: string}[];
-  result: {files: Record<string, {sha256: string; bytes: number}>; qa: {frames: number; full_decode: string; narration: {mode: string}}; cost: {render_wall_seconds: number}} | null;
+  result: {files: Record<string, {sha256: string; bytes: number}>; qa: {frames: number; full_decode: string; narration: {mode: string}; blender_scenes?: {project_reopened: boolean}[]}; cost: {render_wall_seconds: number}} | null;
   provider: Provider;
 };
 type Library = {ok: boolean; compositions: Composition[]; provider: Provider};
@@ -62,6 +62,7 @@ export function ContentMediaWorkbench({goalId}: {goalId: string}) {
     interrupted: copy("上次制作中断，可重新制作", "Previous render interrupted; retry available"), damaged: copy("结果校验失败，请重新制作", "Result verification failed; render again"),
   };
   const providerReady = library?.provider.status === "ready";
+  const hasBlender = selected?.shots.some(shot => shot.kind === "blender");
   return <section className="content-media" aria-label={copy("视频制作", "Video production")}>
     <div className="content-media-heading"><div><h3>{copy("制作视频", "Produce a video")}</h3>
       <p>{copy("让 Agent 准备脚本、来源和时间线，在这里制作并查看作品。", "Have your Agent prepare the story, sources and timeline. Render and review the result here.")}</p></div>
@@ -76,12 +77,15 @@ export function ContentMediaWorkbench({goalId}: {goalId: string}) {
       <div className="content-media-result"><div className="content-media-title"><div><h4>{selected.title}</h4><p role="status">{status[selected.status] ?? selected.status} · {selected.duration_seconds}s · {copy("修订", "Revision")} {selected.revision}</p></div>
         {selected.status === "rendering" ? <button type="button" disabled={busy} onClick={() => void operate("cancel")}>{copy("取消制作", "Cancel render")}</button>
           : <button type="button" disabled={busy || !providerReady || selected.status === "ready"} onClick={() => void operate("render")}>{copy("制作视频", "Render video")}</button>}</div>
+        {hasBlender && selected.status !== "ready" ? <p>{copy("包含 Blender 三维场景。制作需要已安装的本机 Blender 扩展依赖；作品会保留可编辑工程与颜色、深度画面。", "Includes Blender scenes. Rendering needs the local Blender extra; the editable project, color and depth frames are retained.")}</p> : null}
         {selected.status === "ready" && selected.result ? <><video key={`${selected.composition_id}:${selected.result.files["video.mp4"].sha256}`} controls preload="metadata" poster={file("poster.png")} src={file("video.mp4")}>
           <track kind="captions" src={file("captions.vtt")} label={copy("字幕", "Captions")} default /></video>
-          <div className="content-media-downloads"><a href={file("video.mp4")} download="video.mp4">{copy("下载视频", "Download video")}</a><a href={file("captions.srt")} download="captions.srt">{copy("字幕", "Subtitles")}</a><a href={file("transcript.txt")} download="transcript.txt">{copy("文字稿", "Transcript")}</a></div>
+          <div className="content-media-downloads"><a href={file("video.mp4")} download="video.mp4">{copy("下载视频", "Download video")}</a><a href={file("captions.srt")} download="captions.srt">{copy("字幕", "Subtitles")}</a><a href={file("transcript.txt")} download="transcript.txt">{copy("文字稿", "Transcript")}</a>
+            {selected.result.files["blender-project.zip"] ? <a href={file("blender-project.zip")} download="blender-project.zip">{copy("Blender 工程与画面", "Blender project and passes")}</a> : null}</div>
           <p>{copy("完整解码通过", "Full decode passed")} · {selected.result.qa.frames} {copy("帧", "frames")} · {copy("渲染耗时", "Render time")} {selected.result.cost.render_wall_seconds}s</p>
+          {selected.result.qa.blender_scenes?.length ? <p>{copy("三维工程已重新打开并检查，颜色与深度帧完整。", "The 3D project was reopened and checked; color and depth frames are complete.")}</p> : null}
         </> : <ol className="content-media-timeline">{selected.shots.map((shot, i) => <li key={i}><span>{shot.title}</span><small>{shot.seconds}s · {shot.boundary}</small></li>)}</ol>}
-        {["failed", "damaged"].includes(selected.status) ? <p>{copy("请让 Agent 检查素材、字体和配音时长；修改脚本后保存新修订，或修复本机依赖后重试。", "Ask your Agent to check sources, fonts and narration timing. Save a new revision for story changes, or repair the local dependencies and retry.")}</p> : null}
+        {["failed", "damaged"].includes(selected.status) ? <p>{hasBlender ? copy("请让 Agent 检查 Blender 依赖、场景范围与制作时限。修复本机依赖后可重试；修改场景需保存新修订。", "Ask your Agent to check the Blender extra, scene bounds and render time. Retry after dependency repair; save a new revision for scene changes.") : copy("请让 Agent 检查素材、字体和配音时长；修改脚本后保存新修订，或修复本机依赖后重试。", "Ask your Agent to check sources, fonts and narration timing. Save a new revision for story changes, or repair the local dependencies and retry.")}</p> : null}
         <details><summary>{copy("来源与检查", "Sources and checks")}</summary><ul>{selected.shots.map((shot, i) => <li key={i}>{shot.title} — {shot.boundary}<br /><small>{shot.source_ref}</small></li>)}</ul>
           <p>{copy("本机私有作品。编码通过不代表创意质量、理解效果或发布许可；请观看并试听。", "Private local work. Encoding does not establish creative quality, audience understanding or publication approval. Watch and listen before sharing.")}</p></details>
       </div></div> : null}
diff --git a/docs/reference/protocols/content-ops-media-v0.md b/docs/reference/protocols/content-ops-media-v0.md
index 743bde6fc7..208def2046 100644
--- a/docs/reference/protocols/content-ops-media-v0.md
+++ b/docs/reference/protocols/content-ops-media-v0.md
@@ -121,6 +121,43 @@ or repair the existing extension and retry. No failure creates publication
 authority, fills missing footage, infers a creative pass or changes a Goal.
 
 Mechanical rendering, creative quality, audience understanding and operations
-impact have separate evidence. Future Blender, generated media and interactive
+impact have separate evidence. Future generated media and interactive
 learning providers should reuse the nearest content owner and comparison
 method; they are not silently activated by this protocol.
+
+## Blender shot and project readback
+
+The optional `loopx-media` provider can compute a `blender` shot inside the same
+composition. `scene` is a bounded declarative object: an orthographic camera
+with start/end position and target, box/sphere objects with material values
+and optional position keyframes, area lights and connections between object
+IDs. The shared `content_media` TypeScript owner validates it; provider Python
+does not choose the work, sources, publication state or execution authority.
+See the runnable [synthetic example](../../../packages/loopx-media/examples/blender-handoff.json)
+and [activation/recovery guide](../../../packages/loopx-media/README.md#optional-blender-scenes).
+
+Scene IDs and geometry are bound to the plan digest. Position keys must start
+at frame 1, end at the scene's final frame and increase strictly; the first
+position must match the object's declared initial position. A scene supports
+at most 16 primitives, 3 lights, 24 connections and 120 frames. At most 3 Blender
+scenes fit inside a composition. Existing dimension/timeline/output/process
+bounds apply unchanged. Arbitrary scripts, uploaded blend files and external
+asset references are rejected. Ordinary scene-free plans retain their existing
+normalized structure and digest.
+
+Blender 4.5 LTS/Cycles/CPU produces actual RGBA and depth PNG sequences; depth is
+16-bit Z distance normalized over 0–50, with farther values clamped. A fresh
+process opens the saved blend with scripts disabled and checks its geometry,
+animation, camera and timeline. Ready results additionally require the exact
+admitted scene IDs/frame counts, both complete passes, reopen checks and the
+fixed `blender-project.zip` artifact. The archive contains relative-path blend
+projects, exact scene inputs, the replay builder and frames. It is subject to
+the same digest/readback/download scope as the movie; it cannot be attached
+to a scene-free result to bypass admission.
+
+The existing workbench renders/cancels/retries the composition and exposes the
+verified project download. Installation of the Blender extra is explicit;
+missing bpy does not disable ordinary 2D work. A failed 3D attempt retains its
+prepared input and supports retry after dependency repair. No fallback replaces
+3D with a code projection. Mechanical readiness still does not establish
+creative quality, audience understanding or publication approval.
diff --git a/loopx/capabilities/content_ops/media.py b/loopx/capabilities/content_ops/media.py
index d5463e252c..23a62ed918 100644
--- a/loopx/capabilities/content_ops/media.py
+++ b/loopx/capabilities/content_ops/media.py
@@ -13,7 +13,6 @@
 import re
 import stat
 import threading
-from typing import Any
 from uuid import uuid4
 
 from ...control_plane.effect_runtime import effect_runtime_result
@@ -24,7 +23,7 @@
 from .item_lifecycle import apply_content_ops_item_event, build_content_ops_item
 
 PROTOCOL = "content_ops_media_renderer_v0"
-RESULT_FILES = {"video.mp4", "poster.png", "captions.vtt", "captions.srt", "transcript.txt", "narration.wav", "manifest.json"}
+RESULT_FILES = {"video.mp4", "poster.png", "captions.vtt", "captions.srt", "transcript.txt", "narration.wav", "manifest.json", "blender-project.zip"}
 MAX_ASSET_BYTES = 64 * 1024 * 1024
 
 
@@ -218,8 +217,11 @@ def _execute(self, composition_id: str, attempt: str) -> None:
                     "plan": record["plan"], "layout_style": checked["layout_style"],
                     "plan_digest": record["plan_digest"], "frame_count": record["frame_count"],
                     "sources": record["sources"], "attempt_directory": str(_safe_path(bundle, attempt)), "cancel_file": str(cancel)})
+                spatial = [{"id": shot["id"], "frames": round(shot["seconds"] * record["plan"]["fps"])}
+                           for shot in record["plan"]["shots"] if shot["kind"] == "blender"]
                 result = _owner("result", {"result": result, "plan_digest": record["plan_digest"],
                     "frame_count": record["frame_count"], "narration_mode": record["plan"]["narration"]["mode"],
+                    **({"blender_shots": spatial} if spatial else {}),
                     **{k: record["plan"][k] for k in ("width", "height", "fps")}})
                 required = {"video.mp4", "poster.png", "captions.vtt", "captions.srt", "transcript.txt"}
                 if not required <= set(result["files"]) or set(result["files"]) - RESULT_FILES:
diff --git a/loopx/control_plane/capabilities/content_media.ts b/loopx/control_plane/capabilities/content_media.ts
index 5e556f47da..36bb0a1473 100644
--- a/loopx/control_plane/capabilities/content_media.ts
+++ b/loopx/control_plane/capabilities/content_media.ts
@@ -39,6 +39,56 @@ function stable(value: unknown): string {
   if (value && typeof value === "object") return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${JSON.stringify(k)}:${stable(v)}`).join(",")}}`;
   return JSON.stringify(value);
 }
+
+/** Declarative geometry only. Python/bpy computes the admitted scene, never policy. */
+function blenderScene(input: unknown, frames: number) {
+  const scene = object(input);
+  fields(scene, ["camera", "objects", "lights", "connections"]);
+  function vector(value: unknown, min = -25, max = 25): number[] {
+    const result = array(value, 3).map(part => number(part, min, max));
+    if (result.length !== 3) fail("A spatial vector requires three numbers");
+    return result;
+  }
+  const camera = object(scene.camera);
+  fields(camera, ["position", "end_position", "target", "ortho_scale"]);
+  const position = vector(camera.position), end_position = vector(camera.end_position ?? camera.position), target = vector(camera.target);
+  if ([position, end_position].some(point => point.every((part, i) => Math.abs(part - target[i]!) < .01))) fail("The camera must be outside its target");
+  const objects = array(scene.objects, 16).map(value => {
+    const item = object(value);
+    fields(item, ["id", "shape", "position", "scale", "rotation_degrees", "color", "metallic", "roughness", "keyframes"]);
+    if (item.shape !== "box" && item.shape !== "sphere") fail("Select a supported Blender primitive");
+    let previous = 0;
+    const keys = array(item.keyframes ?? [], 24).map(value => {
+      const key = object(value);
+      fields(key, ["frame", "position"]);
+      const frame = number(key.frame, previous + 1, frames, true);
+      previous = frame;
+      return {frame, position: vector(key.position)};
+    });
+    if (keys.length && (keys.length < 2 || keys[0]!.frame !== 1 || keys.at(-1)!.frame !== frames)) fail("Animation must span the first and final scene frame");
+    const location = vector(item.position);
+    if (keys.length && keys[0]!.position.some((part, i) => part !== location[i])) fail("Initial position must match the first keyframe");
+    return {id: token(item.id), shape: item.shape, position: location, scale: vector(item.scale, .05, 8),
+      rotation_degrees: vector(item.rotation_degrees ?? [0, 0, 0], -180, 180), color: vector(item.color, 0, 1),
+      metallic: number(item.metallic ?? .15, 0, 1), roughness: number(item.roughness ?? .4, .05, 1), keyframes: keys};
+  });
+  if (!objects.length || new Set(objects.map(item => item.id)).size !== objects.length) fail("Blender objects require distinct IDs");
+  const lights = array(scene.lights, 3).map(value => {
+    const light = object(value);
+    fields(light, ["position", "energy", "size"]);
+    return {position: vector(light.position), energy: number(light.energy, 50, 2000), size: number(light.size, .5, 10)};
+  });
+  if (!lights.length) fail("A Blender scene requires an explicit light");
+  const connections = array(scene.connections ?? [], 24).map(value => {
+    const link = object(value);
+    fields(link, ["from", "to", "color"]);
+    const from = token(link.from), to = token(link.to);
+    if (from === to || [from, to].some(id => !objects.some(item => item.id === id))) fail("A connection requires two existing scene objects");
+    return {from, to, color: vector(link.color, 0, 1)};
+  });
+  return {camera: {position, end_position, target, ortho_scale: number(camera.ortho_scale, 3, 30)}, objects, lights, connections};
+}
+
 export function validateMediaPlan(input: unknown) {
   const request = object(input), raw = object(request.plan);
   fields(raw, ["schema_version", "title", "width", "height", "fps", "shots", "assets", "captions", "narration", "layout_template_id"]);
@@ -62,11 +112,17 @@ export function validateMediaPlan(input: unknown) {
   if (new Set(assets.map(asset => asset.id)).size !== assets.length) fail("Duplicate source reference");
   const shots = array(raw.shots, 30).map(value => {
     const shot = object(value);
-    fields(shot, ["id", "kind", "seconds", "title", "body", "nodes", "asset_id", "start_seconds", "source_ref", "boundary"]);
+    fields(shot, ["id", "kind", "seconds", "title", "body", "nodes", "asset_id", "start_seconds", "source_ref", "boundary", "scene"]);
     const kind = shot.kind;
-    if (typeof kind !== "string" || !["title", "diagram", "excerpt"].includes(kind)) fail("Unsupported shot kind");
+    if (typeof kind !== "string" || !["title", "diagram", "excerpt", "blender"].includes(kind)) fail("Unsupported shot kind");
+    if (kind !== "blender" && shot.scene !== undefined) fail("Scene geometry requires a Blender shot");
     const base = {id: token(shot.id), kind, seconds: number(shot.seconds, 1, 30), title: text(shot.title, 100),
       body: shot.body == null || shot.body === "" ? "" : text(shot.body, 300), source_ref: text(shot.source_ref, 240), boundary: text(shot.boundary, 180)};
+    if (kind === "blender") {
+      fields(shot, ["id", "kind", "seconds", "title", "body", "source_ref", "boundary", "scene"]);
+      const frames = number(base.seconds * fps, 12, 120, true);
+      return {...base, scene: blenderScene(shot.scene, frames)};
+    }
     if (kind === "diagram") {
       const nodes = array(shot.nodes, 5).map(node => text(node, 48));
       if (nodes.length < 2) fail("A diagram requires at least two nodes");
@@ -80,6 +136,7 @@ export function validateMediaPlan(input: unknown) {
     return base;
   });
   if (!shots.length || new Set(shots.map(shot => shot.id)).size !== shots.length) fail("Shots require distinct IDs");
+  if (shots.filter(shot => shot.kind === "blender").length > 3) fail("A composition supports at most three bounded Blender scenes");
   const duration = shots.reduce((total, shot) => total + shot.seconds, 0);
   if (duration > 90 || shots.some(shot => Math.abs(shot.seconds * fps - Math.round(shot.seconds * fps)) > 1e-7)) fail("Use frame-aligned shots within a 90-second composition");
   let end = 0;
@@ -123,7 +180,7 @@ export function validateMediaResult(input: unknown) {
   if (result.ok !== true || result.protocol !== MEDIA_PROTOCOL || result.plan_digest !== request.plan_digest || result.publish_authorized !== false) fail("Renderer result is not bound to this composition");
   if (qa.full_decode !== "passed" || qa.frames !== request.frame_count || qa.width !== request.width || qa.height !== request.height || qa.fps !== request.fps || qa.source_hashes_verified !== true) fail("Renderer did not qualify the declared timeline");
   const entries = object(result.files), files: Record<string, {sha256: string; bytes: number}> = {};
-  const allowed = ["video.mp4", "poster.png", "captions.vtt", "captions.srt", "transcript.txt", "narration.wav"];
+  const allowed = ["video.mp4", "poster.png", "captions.vtt", "captions.srt", "transcript.txt", "narration.wav", "blender-project.zip"];
   for (const [name, raw] of Object.entries(entries)) {
     if (!allowed.includes(name)) fail("Unexpected renderer file");
     const entry = object(raw);
@@ -131,6 +188,16 @@ export function validateMediaResult(input: unknown) {
     files[name] = {sha256: entry.sha256, bytes: number(entry.bytes, 0, 128 * 1024 * 1024, true)};
   }
   if (["video.mp4", "poster.png", "captions.vtt", "captions.srt", "transcript.txt"].some(name => !files[name])) fail("Renderer output incomplete");
+  const expectedScenes = array(request.blender_shots ?? [], 3).map(object);
+  const spatial = expectedScenes.length ? array(qa.blender_scenes, 3).map((value, i) => {
+    const scene = object(value), expected = expectedScenes[i];
+    if (!expected || scene.id !== expected.id || scene.frames !== expected.frames || scene.project_reopened !== true || scene.engine !== "CYCLES" || scene.rgba_frames !== expected.frames || scene.depth_frames !== expected.frames) fail("Blender output does not match the admitted scene and passes");
+    const version = text(scene.blender_version, 40);
+    if (!/^4\.5\.\d+(?: LTS)?$/.test(version)) fail("This Blender provider supports the qualified 4.5 LTS API");
+    return {id: scene.id, frames: scene.frames, rgba_frames: scene.rgba_frames, depth_frames: scene.depth_frames,
+      project_reopened: true, engine: "CYCLES", blender_version: version};
+  }) : [];
+  if (spatial.length !== expectedScenes.length || Boolean(files["blender-project.zip"]) !== Boolean(expectedScenes.length)) fail("Blender project output is missing or out of scope");
   const narration = object(qa.narration);
   if (!["silent", "supplied", "system_speech"].includes(String(narration.mode)) || narration.mode !== request.narration_mode) fail("Narration result differs from the admitted plan");
   if (narration.mode !== "silent" && !files["narration.wav"]) fail("Narration output is missing");
@@ -141,6 +208,7 @@ export function validateMediaResult(input: unknown) {
   return {ok: true, protocol: MEDIA_PROTOCOL, plan_digest: request.plan_digest, files,
     qa: {full_decode: "passed", frames: qa.frames, width: qa.width, height: qa.height, fps: qa.fps,
       source_hashes_verified: true, narration: {mode: narration.mode, ...audioMetrics, subjective_listening: "not_tested"},
+      ...(spatial.length ? {blender_scenes: spatial} : {}),
       audience_understanding: "not_tested", creative_review: "not_tested"},
     cost: {render_wall_seconds: number(cost.render_wall_seconds, 0, 120)}, publish_authorized: false};
 }
diff --git a/packages/loopx-media/README.md b/packages/loopx-media/README.md
index 291d806de9..63d11a5420 100644
--- a/packages/loopx-media/README.md
+++ b/packages/loopx-media/README.md
@@ -37,7 +37,59 @@ decode. Images retain their orientation; video excerpts retain aspect ratio.
 Installed fonts must cover the visible text, with CJK line breaking supported.
 RTL shaping and arbitrary font discovery are not qualified. macOS speech is
 optional; other platforms require supplied audio or explicit silence.
-No cloud voice, generative image/video, Blender or game engine is bundled here.
+No cloud voice, generative image/video or game engine is bundled here.
+
+## Optional Blender scenes
+
+For real 3D geometry, install the same provider with its optional Blender extra
+in a Python 3.11 environment, then register and doctor the current manifest:
+
+```sh
+uv tool install --python 3.11 './packages/loopx-media[blender]'
+loopx extension install --manifest packages/loopx-media/extension.toml --execute
+loopx extension doctor loopx-media --execute
+loopx content-ops media prepare --goal-id GOAL \
+  --plan-json packages/loopx-media/examples/blender-handoff.json \
+  --source-directory .
+```
+
+If this provider is already installed, use the package manager's explicit
+upgrade/reinstall operation before registering the new manifest revision with
+`loopx extension upgrade --manifest packages/loopx-media/extension.toml --execute`.
+The registered executable and its Python environment are pinned. Install the
+extra in that environment and run doctor; changing the calling process's PATH
+does not replace a registered executable. Doctor checks the pinned installation,
+not whether some other environment has Blender. A move to another environment
+needs explicit extension registration; doctor cannot rebind an active revision.
+Preparation does not install Blender. The ordinary install still supports 2D;
+a missing Blender extra fails only an attempted 3D scene. Repair that local
+dependency and retry the unchanged prepared composition through the same CLI
+or **Content production** workbench. No second provider setting is needed.
+
+An Agent selects a `blender` shot and supplies declarative objects, camera,
+lights, materials and position keyframes. The shared TypeScript owner admits
+those fields and includes them in the composition digest. The optional provider
+runs actual Blender 4.5 LTS/Cycles on CPU in a separate process. Uploaded blend
+files, arbitrary Python, add-ons and external asset discovery are unsupported.
+Blender 5.x uses a different compositor API and is not qualified by this provider.
+
+The workbench previews the composed movie and downloads **Blender project and
+passes**. The verified ZIP retains each `scene.blend`, its input, the replay
+builder, RGBA frames and a 16-bit depth pass. Depth maps Blender Z distance 0–50
+to 0–65535 and clamps values beyond 50. Scene output paths are relative; opening
+the blend with scripts disabled does not require embedded code. A second
+process reopens each saved project and checks its geometry, keyframes, camera
+and timeline before the composition can become ready. The normal renderer
+then composites the RGBA frames with the selected layout and verifies the
+complete encoded timeline. This does not establish the illustration's factual
+truth, explanatory quality or audience understanding.
+
+The versioned example is a five-second synthetic artifact round trip, not a
+recorded Agent run or a finished creative direction. Reuse a verified result
+as a digest-bound video excerpt in a larger composition instead of rerendering
+unchanged 3D footage. Keep source boundaries and the editable project.
+Reusing verified output preserves exact bytes. Re-rendering an editable scene
+is separate: CPU rendering can vary in the last color bit between processes.
 
 The renderer refuses a short excerpt, changed source, missing glyphs, text
 overflow or speech longer than its cue. It does not fill missing footage,
@@ -62,6 +114,10 @@ caption cues, with at most 1920×1080 at 30 fps. Each source is at most 64 MiB;
 all source snapshots together are at most 128 MiB. The render has a 120-second
 process budget. A complex valid plan can exceed the local machine's budget;
 that is a failed attempt, not a reason to mark a partial movie ready.
+Each Blender scene has at most 16 box/sphere objects, 3 area lights, 24 connections
+and 120 frames; a composition can include at most 3 scenes. Scene rendering,
+reopening, pass checks and composition share the existing 120-second process
+budget. Failed or cancelled attempts never substitute a diagram or frozen frame.
 
 The result records exact output digests, decoded frames, render wall time,
 PCM peak/clipping measurements when audio exists, and untested creative,
@@ -109,3 +165,18 @@ decoded VTT/SRT text must preserve accepted line breaks, ampersands and quotes.
 The source qualification checks the editable module and executable environment
 so a cached wheel cannot silently stand in for the source under review.
 It is integration evidence, not a subjective or comparative creative study.
+
+For an explicit source qualification of the optional Blender computation,
+use an isolated project environment so the normal interpreter stays intact:
+
+```sh
+UV_PROJECT_ENVIRONMENT=.local/blender-test-env \
+LOOPX_MEDIA_BLENDER_TEST=1 \
+uv run --python 3.11 --extra test --with-editable './packages/loopx-media[blender]' \
+  python -m pytest -q tests/test_content_media.py
+```
+
+The opt-in test uses the real extension and HTTP route, inspects the ZIP,
+opens the blend in an independent bpy process and checks stored scene state.
+It performs no cloud/model calls or public uploads. Report the actual bpy
+version and platform; this command is not a claim of cross-platform delivery.
diff --git a/packages/loopx-media/examples/blender-handoff.json b/packages/loopx-media/examples/blender-handoff.json
new file mode 100644
index 0000000000..e2b79e6c3c
--- /dev/null
+++ b/packages/loopx-media/examples/blender-handoff.json
@@ -0,0 +1,58 @@
+{
+  "schema_version": "content_ops_media_plan_v0",
+  "title": "A scoped artifact round trip",
+  "width": 640,
+  "height": 360,
+  "fps": 12,
+  "shots": [
+    {
+      "id": "intent", "kind": "title", "seconds": 1,
+      "title": "One request. Scoped work.",
+      "source_ref": "synthetic:artifact-route",
+      "boundary": "Mechanism illustration; not an execution trace"
+    },
+    {
+      "id": "route", "kind": "blender", "seconds": 3,
+      "title": "Artifacts travel. Authority stays scoped.",
+      "source_ref": "synthetic:artifact-route",
+      "boundary": "Illustrated movement does not prove adoption or acceptance",
+      "scene": {
+        "camera": {"position": [6, -10, 7], "end_position": [3, -11, 7], "target": [0, 0, 0.6], "ortho_scale": 7.5},
+        "objects": [
+          {"id": "requester", "shape": "box", "position": [-2, 0, 0], "scale": [1.3, 1.4, 0.3], "color": [0.04, 0.24, 0.8]},
+          {"id": "worker", "shape": "box", "position": [0, 0, 0], "scale": [1.3, 1.4, 0.3], "color": [0.42, 0.12, 0.72]},
+          {"id": "reviewer", "shape": "box", "position": [2, 0, 0], "scale": [1.3, 1.4, 0.3], "color": [0.02, 0.52, 0.4]},
+          {"id": "artifact", "shape": "sphere", "position": [-2, 0, 0.8], "scale": [0.4, 0.4, 0.4], "color": [0.98, 0.45, 0.025], "metallic": 0.4, "roughness": 0.25,
+            "keyframes": [
+              {"frame": 1, "position": [-2, 0, 0.8]},
+              {"frame": 10, "position": [0, 0, 0.8]},
+              {"frame": 19, "position": [2, 0, 0.8]},
+              {"frame": 28, "position": [0, 0, 0.8]},
+              {"frame": 36, "position": [-2, 0, 0.8]}
+            ]}
+        ],
+        "connections": [
+          {"from": "requester", "to": "worker", "color": [0.12, 0.4, 0.9]},
+          {"from": "worker", "to": "reviewer", "color": [0.12, 0.4, 0.9]}
+        ],
+        "lights": [
+          {"position": [-3, -4, 8], "energy": 900, "size": 7},
+          {"position": [4, 2, 6], "energy": 700, "size": 5}
+        ]
+      }
+    },
+    {
+      "id": "evidence", "kind": "title", "seconds": 1,
+      "title": "Return evidence to the requester.",
+      "source_ref": "synthetic:artifact-route",
+      "boundary": "A returned file still needs independent acceptance"
+    }
+  ],
+  "captions": [
+    {"start": 0, "end": 1, "text": "One request. Scoped work.", "language": "en"},
+    {"start": 1, "end": 2.5, "text": "Requester, worker, reviewer: left to right.", "language": "en"},
+    {"start": 2.5, "end": 4, "text": "The artifact returns. Authority stays scoped.", "language": "en"},
+    {"start": 4, "end": 5, "text": "Return evidence for independent acceptance.", "language": "en"}
+  ],
+  "narration": {"mode": "silent"}
+}
diff --git a/packages/loopx-media/extension.toml b/packages/loopx-media/extension.toml
index 258b6b5005..df2d584cac 100644
--- a/packages/loopx-media/extension.toml
+++ b/packages/loopx-media/extension.toml
@@ -1,6 +1,6 @@
 schema_version = "loopx_extension_manifest_v0"
 id = "loopx-media"
-version = "0.1.0"
+version = "0.2.0"
 requires_loopx_api = ">=1,<2"
 permissions = ["content_media_write"]
 
diff --git a/packages/loopx-media/pyproject.toml b/packages/loopx-media/pyproject.toml
index 623ee5d25a..f8f70f5152 100644
--- a/packages/loopx-media/pyproject.toml
+++ b/packages/loopx-media/pyproject.toml
@@ -4,11 +4,14 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "loopx-media"
-version = "0.1.0"
+version = "0.2.0"
 description = "Optional local composition renderer for LoopX content-ops"
 requires-python = ">=3.11"
 dependencies = ["Pillow>=11,<13", "imageio-ffmpeg>=0.6,<0.7", "fonttools>=4,<5"]
 
+[project.optional-dependencies]
+blender = ["bpy==4.5.12"]
+
 [project.scripts]
 loopx-media = "loopx_media.renderer:main"
 
diff --git a/packages/loopx-media/src/loopx_media/blender.py b/packages/loopx-media/src/loopx_media/blender.py
new file mode 100644
index 0000000000..c61925a715
--- /dev/null
+++ b/packages/loopx-media/src/loopx_media/blender.py
@@ -0,0 +1,362 @@
+"""Optional Blender 4.5 computation behind content-ops' admitted scene port.
+
+Only this subprocess imports bpy. Input is bounded declarative geometry, never
+user Python, an uploaded blend, an add-on or a filesystem discovery request.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import json
+import math
+from pathlib import Path
+import subprocess
+import sys
+import time
+import zipfile
+
+
+def available() -> bool:
+    return importlib.util.find_spec("bpy") is not None
+
+
+def _call(mode: str, request: Path, directory: Path, check) -> None:
+    # File-backed logs avoid a full stderr pipe blocking a real Blender render.
+    with (directory.parent / f"{directory.name}-{mode}.log").open("wb") as log:
+        process = subprocess.Popen(
+            [
+                sys.executable,
+                str(Path(__file__).resolve()),
+                mode,
+                str(request),
+                str(directory),
+            ],
+            stdout=log,
+            stderr=subprocess.STDOUT,
+        )
+        try:
+            while process.poll() is None:
+                check()
+                time.sleep(0.1)
+            if process.returncode:
+                raise ValueError("Blender could not complete the declared scene")
+        finally:
+            if process.poll() is None:
+                process.terminate()
+                try:
+                    process.wait(timeout=3)
+                except subprocess.TimeoutExpired:
+                    process.kill()
+                    process.wait()
+
+
+def render_shot(shot: dict, plan: dict, out: Path, check) -> tuple[Path, dict]:
+    if not available():
+        raise ValueError(
+            "Install the optional Blender extra before rendering this scene"
+        )
+    parent = out / "blender"
+    parent.mkdir(exist_ok=True)
+    directory = parent / shot["id"]
+    request = parent / f"{shot['id']}.json"
+    payload = {
+        "scene": shot["scene"],
+        "width": plan["width"],
+        "height": plan["height"],
+        "fps": plan["fps"],
+        "frames": round(shot["seconds"] * plan["fps"]),
+    }
+    request.write_text(
+        json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
+    )
+    _call("render", request, directory, check)
+    _call("verify", request, directory, check)
+    qa = json.loads((directory / "qa.json").read_text(encoding="utf-8"))
+    from PIL import Image
+
+    expected = [f"frame-{i:04}.png" for i in range(1, payload["frames"] + 1)]
+    for name in ("rgba", "depth"):
+        paths = sorted((directory / name).glob("*.png"))
+        if [path.name for path in paths] != expected:
+            raise ValueError("Blender did not render every declared pass frame")
+        for path in paths:
+            check()
+            with Image.open(path) as image:
+                image.load()
+                if image.size != (plan["width"], plan["height"]):
+                    raise ValueError(
+                        "Blender pass dimensions differ from the admitted scene"
+                    )
+                if name == "rgba" and (
+                    image.mode != "RGBA" or not image.getchannel("A").getbbox()
+                ):
+                    raise ValueError(
+                        "The Blender scene contains no visible RGBA geometry"
+                    )
+                if name == "depth" and (
+                    image.mode not in {"I", "I;16"}
+                    or image.getextrema()[0] == image.getextrema()[1]
+                ):
+                    raise ValueError("The Blender depth pass contains no scene range")
+    return directory / "rgba", {
+        "id": shot["id"],
+        "frames": payload["frames"],
+        "rgba_frames": len(expected),
+        "depth_frames": len(expected),
+        **qa,
+    }
+
+
+def project_archive(plan: dict, out: Path) -> None:
+    root = out / "blender"
+    if not root.is_dir():
+        return
+    # Replay uses a fresh destination and the same builder, not embedded blend scripts.
+    (root / "scene-builder.py").write_bytes(Path(__file__).read_bytes())
+    (root / "plan.json").write_text(
+        json.dumps(plan, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
+    )
+    (root / "README.txt").write_text(
+        "Private illustrative Blender project. No publication approval.\n"
+        "Requires Python3.11 and bpy4.5 LTS. For each SHOT.json:\n"
+        "python scene-builder.py render SHOT.json NEW_DIRECTORY\n"
+        "python scene-builder.py verify SHOT.json NEW_DIRECTORY\n"
+        "Each scene.blend can be opened with scripts disabled. Paths are relative.\n"
+        "rgba/ contains straight RGBA PNG frames. depth/ contains a 16-bit Z pass\n"
+        "mapped from distance0..50 to0..65535, with values beyond50 clamped.\n"
+        "CPU Cycles8samples; quality and comprehension still require review.\n",
+        encoding="utf-8",
+    )
+    paths = [
+        path
+        for path in sorted(root.rglob("*"))
+        if path.is_file() and path.suffix != ".log"
+    ]
+    if sum(path.stat().st_size for path in paths) > 128 * 1024 * 1024:
+        raise ValueError("The Blender project exceeds the bounded output budget")
+    with zipfile.ZipFile(
+        out / "blender-project.zip", "x", compression=zipfile.ZIP_DEFLATED
+    ) as archive:
+        for path in paths:
+            archive.write(path, path.relative_to(root).as_posix())
+
+
+def _blender():
+    import bpy
+
+    if bpy.app.version[:2] != (4, 5):
+        raise ValueError("This provider supports the Blender4.5 LTS API")
+    return bpy
+
+
+def _material(bpy, name, color, metallic=0.15, roughness=0.4):
+    material = bpy.data.materials.new(name)
+    material.use_nodes = True
+    node = material.node_tree.nodes["Principled BSDF"]
+    node.inputs["Base Color"].default_value = (*color, 1)
+    node.inputs["Metallic"].default_value = metallic
+    node.inputs["Roughness"].default_value = roughness
+    return material
+
+
+def _render(request: dict, directory: Path) -> None:
+    bpy = _blender()
+    from mathutils import Vector
+
+    directory.mkdir(mode=0o700, exist_ok=False)
+    for name in ("rgba", "depth"):
+        (directory / name).mkdir(mode=0o700)
+    bpy.ops.wm.read_factory_settings(use_empty=True)
+    bpy.context.preferences.filepaths.use_scripts_auto_execute = False
+    bpy.context.preferences.edit.keyframe_new_interpolation_type = "LINEAR"
+    scene = bpy.context.scene
+    scene.render.engine = "CYCLES"
+    scene.cycles.device = "CPU"
+    scene.cycles.samples = 8
+    scene.cycles.use_denoising = True
+    scene.render.threads_mode = "FIXED"
+    scene.render.threads = 4
+    scene.render.resolution_x, scene.render.resolution_y = (
+        request["width"],
+        request["height"],
+    )
+    scene.render.resolution_percentage = 100
+    scene.render.fps = request["fps"]
+    scene.frame_start, scene.frame_end = 1, request["frames"]
+    scene.render.image_settings.file_format = "PNG"
+    scene.render.image_settings.color_mode = "RGBA"
+    scene.render.film_transparent = True
+    scene.view_settings.view_transform = "Standard"
+    scene.world = bpy.data.worlds.new("Neutral studio")
+    scene.world.use_nodes = True
+    scene.world.node_tree.nodes["Background"].inputs["Strength"].default_value = 0.35
+    specification = request["scene"]
+    for item in specification["objects"]:
+        if item["shape"] == "box":
+            bpy.ops.mesh.primitive_cube_add(size=1, location=item["position"])
+        elif item["shape"] == "sphere":
+            bpy.ops.mesh.primitive_uv_sphere_add(
+                segments=24, ring_count=12, radius=0.5, location=item["position"]
+            )
+        else:
+            raise ValueError("Unsupported geometry")
+        ob = bpy.context.object
+        ob.name = item["id"]
+        ob.scale = item["scale"]
+        ob.rotation_euler = [math.radians(value) for value in item["rotation_degrees"]]
+        bpy.ops.object.transform_apply(location=False, rotation=False, scale=True)
+        ob.data.materials.append(
+            _material(
+                bpy, item["id"], item["color"], item["metallic"], item["roughness"]
+            )
+        )
+        if item["shape"] == "box":
+            bevel = ob.modifiers.new("Soft edge", "BEVEL")
+            bevel.width, bevel.segments = 0.06, 3
+        else:
+            for face in ob.data.polygons:
+                face.use_smooth = True
+        for key in item["keyframes"]:
+            ob.location = key["position"]
+            ob.keyframe_insert(data_path="location", frame=key["frame"])
+    for index, link in enumerate(specification["connections"]):
+        a = Vector(
+            next(
+                item["position"]
+                for item in specification["objects"]
+                if item["id"] == link["from"]
+            )
+        )
+        b = Vector(
+            next(
+                item["position"]
+                for item in specification["objects"]
+                if item["id"] == link["to"]
+            )
+        )
+        curve = bpy.data.curves.new(f"Connection-{index}", "CURVE")
+        curve.dimensions, curve.bevel_depth, curve.bevel_resolution = "3D", 0.025, 3
+        spline = curve.splines.new("POLY")
+        spline.points.add(32)
+        for i, point in enumerate(spline.points):
+            t = i / 32
+            point.co = (
+                *(a.lerp(b, t) + Vector((0, 0, 0.65 * math.sin(math.pi * t)))),
+                1,
+            )
+        ob = bpy.data.objects.new(f"Connection-{index}", curve)
+        scene.collection.objects.link(ob)
+        curve.materials.append(_material(bpy, f"Route-{index}", link["color"]))
+    camera = specification["camera"]
+    bpy.ops.object.camera_add()
+    scene.camera = bpy.context.object
+    scene.camera.name = "Scene camera"
+    scene.camera.data.type, scene.camera.data.ortho_scale = (
+        "ORTHO",
+        camera["ortho_scale"],
+    )
+    scene.camera.data.clip_end = 50
+    for frame, position in (
+        (1, camera["position"]),
+        (request["frames"], camera["end_position"]),
+    ):
+        scene.camera.location = position
+        scene.camera.rotation_euler = (
+            (Vector(camera["target"]) - scene.camera.location)
+            .to_track_quat("-Z", "Y")
+            .to_euler()
+        )
+        scene.camera.keyframe_insert(data_path="location", frame=frame)
+        scene.camera.keyframe_insert(data_path="rotation_euler", frame=frame)
+    for item in specification["lights"]:
+        bpy.ops.object.light_add(type="AREA", location=item["position"])
+        lamp = bpy.context.object
+        lamp.data.energy, lamp.data.size = item["energy"], item["size"]
+        lamp.rotation_euler = (
+            (Vector(camera["target"]) - lamp.location)
+            .to_track_quat("-Z", "Y")
+            .to_euler()
+        )
+    scene.view_layers[0].use_pass_z = True
+    scene.use_nodes = True
+    nodes, links = scene.node_tree.nodes, scene.node_tree.links
+    nodes.clear()
+    layers = nodes.new("CompositorNodeRLayers")
+    links.new(
+        layers.outputs["Image"], nodes.new("CompositorNodeComposite").inputs["Image"]
+    )
+    depth = nodes.new("CompositorNodeMapRange")
+    depth.inputs["From Min"].default_value, depth.inputs["From Max"].default_value = (
+        0,
+        50,
+    )
+    depth.use_clamp = True
+    links.new(layers.outputs["Depth"], depth.inputs["Value"])
+    output = nodes.new("CompositorNodeOutputFile")
+    output.save_as_render = False
+    output.file_slots[0].save_as_render = False
+    output.file_slots[0].use_node_format = True
+    output.base_path, output.file_slots[0].path = "//depth", "frame-"
+    output.format.file_format, output.format.color_mode, output.format.color_depth = (
+        "PNG",
+        "BW",
+        "16",
+    )
+    links.new(depth.outputs["Value"], output.inputs[0])
+    scene.render.filepath = "//rgba/frame-"
+    scene.frame_set(1)
+    bpy.ops.wm.save_as_mainfile(filepath=str(directory / "scene.blend"), compress=True)
+    bpy.ops.render.render(animation=True)
+
+
+def _verify(request: dict, directory: Path) -> None:
+    bpy = _blender()
+    bpy.ops.wm.open_mainfile(
+        filepath=str(directory / "scene.blend"), load_ui=False, use_scripts=False
+    )
+    scene = bpy.context.scene
+    if (
+        scene.render.engine != "CYCLES"
+        or scene.frame_end != request["frames"]
+        or scene.frame_start != 1
+        or scene.render.resolution_x != request["width"]
+        or scene.render.resolution_y != request["height"]
+        or scene.render.fps != request["fps"]
+        or not scene.render.film_transparent
+        or not scene.view_layers[0].use_pass_z
+    ):
+        raise ValueError("Saved Blender project differs from the scene")
+    for item in request["scene"]["objects"]:
+        ob = scene.objects.get(item["id"])
+        if ob is None or ob.type != "MESH" or not ob.data.materials:
+            raise ValueError("Saved Blender geometry is missing")
+        for key in item["keyframes"]:
+            scene.frame_set(key["frame"])
+            if any(abs(a - b) > 1e-4 for a, b in zip(ob.location, key["position"])):
+                raise ValueError("Saved animation differs from declared keyframes")
+    for frame, field in ((1, "position"), (request["frames"], "end_position")):
+        scene.frame_set(frame)
+        if any(
+            abs(a - b) > 1e-4
+            for a, b in zip(scene.camera.location, request["scene"]["camera"][field])
+        ):
+            raise ValueError("Saved camera animation differs")
+    (directory / "qa.json").write_text(
+        json.dumps(
+            {
+                "project_reopened": True,
+                "engine": scene.render.engine,
+                "blender_version": bpy.app.version_string,
+            }
+        )
+        + "\n",
+        encoding="utf-8",
+    )
+
+
+if __name__ == "__main__":
+    mode, source, destination = sys.argv[1:]
+    if mode not in {"render", "verify"}:
+        raise ValueError("Unsupported Blender worker operation")
+    payload = json.loads(Path(source).read_text(encoding="utf-8"))
+    (_render if mode == "render" else _verify)(payload, Path(destination).resolve())
diff --git a/packages/loopx-media/src/loopx_media/renderer.py b/packages/loopx-media/src/loopx_media/renderer.py
index 87fff7e228..8b0db2e640 100644
--- a/packages/loopx-media/src/loopx_media/renderer.py
+++ b/packages/loopx-media/src/loopx_media/renderer.py
@@ -139,6 +139,16 @@ def check():
     ff = imageio_ffmpeg.get_ffmpeg_exe()
     captions(plan, out)
     audio = soundtrack(plan, sources, out, ff, check)
+    spatial_frames, spatial_qa = {}, []
+    if any(shot["kind"] == "blender" for shot in plan["shots"]):
+        from .blender import project_archive, render_shot
+        for shot in plan["shots"]:
+            if shot["kind"] == "blender":
+                frames, qa = render_shot(shot, plan, out, check)
+                spatial_frames[shot["id"]] = frames
+                spatial_qa.append(qa)
+        project_archive(plan, out)
+    check()
     width, height, fps = plan["width"], plan["height"], plan["fps"]
     scale = width / 1280
     style = request["layout_style"]
@@ -204,8 +214,11 @@ def draw_text(draw, position, text, size, color=INK, max_width=None, max_lines=4
                     margin = round(56 * scale)
                     draw_text(draw, (margin, round(27 * scale)), "LOOPX / CONTENT STUDIO", 16, accent)
                     draw.line((margin, round(65 * scale), width - margin, round(65 * scale)), fill=LINE)
-                    if shot["kind"] == "excerpt":
+                    if shot["kind"] in {"excerpt", "blender"}:
                         frame = source_image
+                        if shot["kind"] == "blender":
+                            with Image.open(spatial_frames[shot["id"]] / f"frame-{n+1:04}.png") as image:
+                                frame = image.convert("RGBA")
                         if decoder:
                             raw = decoder.stdout.read(width * height * 3)
                             if len(raw) != width * height * 3:
@@ -213,7 +226,7 @@ def draw_text(draw, position, text, size, color=INK, max_width=None, max_lines=4
                             frame = Image.frombytes("RGB", (width, height), raw)
                         fitted = frame.copy()
                         fitted.thumbnail((width - 2 * margin, round(height * 0.62)))
-                        im.paste(fitted, ((width - fitted.width) // 2, round(height * 0.27)))
+                        im.paste(fitted, ((width - fitted.width) // 2, round(height * 0.27)), fitted.getchannel("A") if fitted.mode == "RGBA" else None)
                         draw_text(draw, (margin, round(88 * scale)), shot["title"], 32, ink, max_lines=2)
                     else:
                         enter = 1 - (1 - min(1, n / max(1, fps * 0.6))) ** 3
@@ -276,7 +289,8 @@ def draw_text(draw, position, text, size, color=INK, max_width=None, max_lines=4
     files = {path.name: {"sha256": digest(path), "bytes": path.stat().st_size} for path in out.iterdir() if path.is_file()}
     result = {"ok": True, "protocol": PROTOCOL, "plan_digest": request["plan_digest"], "files": files,
               "qa": {"full_decode": "passed", "frames": frames, "width": width, "height": height, "fps": fps,
-                     "source_hashes_verified": True, "narration": audio, "audience_understanding": "not_tested", "creative_review": "not_tested"},
+                     "source_hashes_verified": True, "narration": audio, **({"blender_scenes": spatial_qa} if spatial_qa else {}),
+                     "audience_understanding": "not_tested", "creative_review": "not_tested"},
               "cost": {"render_wall_seconds": round(time.monotonic() - started, 3)}, "publish_authorized": False}
     (out / "manifest.json").write_text(json.dumps(result, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
     return result
@@ -286,10 +300,11 @@ def main() -> int:
     os.umask(0o077)
     try:
         if sys.argv[1:] == ["--doctor"]:
+            from .blender import available
             ff = imageio_ffmpeg.get_ffmpeg_exe()
             run([ff, "-version"], timeout=5)
             if not font_file(): raise ValueError("Install a supported local font")
-            print(json.dumps({"ok": True, "protocol": PROTOCOL, "system_speech": sys.platform == "darwin", "font": "system"}))
+            print(json.dumps({"ok": True, "protocol": PROTOCOL, "system_speech": sys.platform == "darwin", "font": "system", "blender_extra_present": available()}))
             return 0
         raw = sys.stdin.buffer.read(1024 * 1024 + 1)
         if len(raw) > 1024 * 1024: raise ValueError("Render request exceeds the protocol limit")
diff --git a/tests/control_plane_ts/content_media.test.ts b/tests/control_plane_ts/content_media.test.ts
index d9fcf574d7..21390de3ca 100644
--- a/tests/control_plane_ts/content_media.test.ts
+++ b/tests/control_plane_ts/content_media.test.ts
@@ -1,5 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
+import {readFileSync} from "node:fs";
 import {validateMediaPlan as plan, validateMediaResult as result, transitionMediaRender as transition} from "../../loopx/control_plane/capabilities/content_media.ts";
 
 const brief = () => ({schema_version: "content_ops_media_plan_v0", title: "Return the evidence", width: 1280, height: 720, fps: 24,
@@ -81,3 +82,54 @@ test("caption admission preserves plain text and refuses structural paragraph se
     assert.throws(() => plan({plan: caption(text)}), /markup and entity/);
   }
 });
+
+const spatialBrief = () => JSON.parse(readFileSync(new URL("../../packages/loopx-media/examples/blender-handoff.json", import.meta.url), "utf8"));
+
+test("Blender scene geometry and camera belong to the same source-bound composition", () => {
+  const raw = spatialBrief(), checked = plan({plan: raw});
+  assert.equal(checked.frame_count, 60);
+  assert.equal(checked.publish_authorized, false);
+  assert.equal(plan({plan: checked.plan}).plan_digest, checked.plan_digest);
+  for (const change of [(p: any) => p.shots[1].scene.camera.end_position[0] += 1,
+    (p: any) => p.shots[1].scene.objects[3].keyframes[2].position[2] += .2,
+    (p: any) => p.shots[1].scene.lights[0].energy += 1]) {
+    const revised = spatialBrief(); change(revised);
+    assert.notEqual(plan({plan: revised}).plan_digest, checked.plan_digest);
+  }
+  // The old scene-free plan stays scene-free; no default geometry/provider setting.
+  assert.equal("scene" in plan({plan: brief()}).plan.shots[0]!, false);
+});
+
+test("Blender refuses executable input, escaping IDs and undeclared animation", () => {
+  const changes = [(p: any) => p.shots[1].scene.script = "arbitrary Python",
+    (p: any) => p.shots[1].scene.blend_path = "outside.blend",
+    (p: any) => p.shots[1].id = "../escape",
+    (p: any) => p.shots[1].scene.objects[0].shape = "script",
+    (p: any) => p.shots[1].scene.objects[0].color = [0, 1, 2],
+    (p: any) => p.shots[1].scene.objects[3].keyframes[0].frame = 2,
+    (p: any) => p.shots[1].scene.objects[3].keyframes[2].frame = 10,
+    (p: any) => p.shots[1].scene.objects[3].keyframes.at(-1).position[0] = Infinity,
+    (p: any) => p.shots[1].scene.camera.position = p.shots[1].scene.camera.target,
+    (p: any) => p.shots[1].scene.connections[0].to = "unknown",
+    (p: any) => p.shots[1].scene.lights = [],
+    (p: any) => p.shots[1].seconds = 30];
+  for (const change of changes) {const p = spatialBrief(); change(p); assert.throws(() => plan({plan: p}));}
+});
+
+test("Blender readiness requires the admitted passes and a reopened project, not only MP4 bytes", () => {
+  const expected = {plan_digest: "sha256:" + "a".repeat(64), frame_count: 60, width: 640, height: 360, fps: 12,
+    narration_mode: "silent", blender_shots: [{id: "route", frames: 36}]};
+  const scene = {id: "route", frames: 36, rgba_frames: 36, depth_frames: 36,
+    project_reopened: true, engine: "CYCLES", blender_version: "4.5.12 LTS"};
+  const output = {ok: true, protocol: "content_ops_media_renderer_v0", plan_digest: expected.plan_digest,
+    files: Object.fromEntries(["video.mp4", "poster.png", "captions.vtt", "captions.srt", "transcript.txt", "blender-project.zip"].map(name => [name, {sha256: "b".repeat(64), bytes: 16}])),
+    qa: {full_decode: "passed", frames: 60, width: 640, height: 360, fps: 12, source_hashes_verified: true,
+      narration: {mode: "silent"}, blender_scenes: [scene]}, cost: {render_wall_seconds: 45}, publish_authorized: false};
+  assert.equal(result({...expected, result: output}).qa.blender_scenes?.[0]?.project_reopened, true);
+  for (const changed of [{...scene, frames: 35}, {...scene, depth_frames: 35}, {...scene, id: "other"},
+    {...scene, project_reopened: false}, {...scene, blender_version: "5.0.0"}]) {
+    assert.throws(() => result({...expected, result: {...output, qa: {...output.qa, blender_scenes: [changed]}}}));
+  }
+  assert.throws(() => result({...expected, result: {...output, files: {...output.files, "blender-project.zip": undefined}}}));
+  assert.throws(() => result({...expected, blender_shots: [], result: output}), /scope/);
+});
diff --git a/tests/test_content_media.py b/tests/test_content_media.py
index e7c036ec9e..2245f0e5f6 100644
--- a/tests/test_content_media.py
+++ b/tests/test_content_media.py
@@ -319,20 +319,11 @@ def test_real_http_admission_rejects_foreign_goal_origin_and_path_injection(
     assert b"source_directory" not in body and str(work.project).encode() not in body
 
 
-@pytest.mark.skipif(
-    os.environ.get("LOOPX_MEDIA_RENDERER_TEST") != "1",
-    reason="explicit optional local renderer qualification",
-)
-def test_real_optional_renderer_reuse_and_http_byte_readback(http_workspace):
-    """No model calls: use the actual extension, encoder, store and HTTP route."""
+def _install_source_renderer(work):
     import subprocess
     import sys
-    from urllib.parse import urlencode
-
-    import imageio_ffmpeg
     import loopx_media.renderer as renderer
 
-    work, exchange = http_workspace
     executable = shutil.which("loopx-media")
     assert executable, (
         "Install packages/loopx-media in an isolated environment and put its executable on PATH"
@@ -361,6 +352,21 @@ def test_real_optional_renderer_reuse_and_http_byte_readback(http_workspace):
         text=True,
     )
     assert installed.returncode == 0, installed.stdout + installed.stderr
+    return root, command, state
+
+
+@pytest.mark.skipif(
+    os.environ.get("LOOPX_MEDIA_RENDERER_TEST") != "1",
+    reason="explicit optional local renderer qualification",
+)
+def test_real_optional_renderer_reuse_and_http_byte_readback(http_workspace):
+    """No model calls: use the actual extension, encoder, store and HTTP route."""
+    import subprocess
+    import imageio_ffmpeg
+    from urllib.parse import urlencode
+
+    work, exchange = http_workspace
+    _, command, state = _install_source_renderer(work)
     first_plan = brief()
     caption_text = 'FIRST & SECOND "quoted"\nReturn evidence; preserve both lines.'
     first_plan["captions"][0]["text"] = caption_text
@@ -490,3 +496,127 @@ def test_real_optional_renderer_reuse_and_http_byte_readback(http_workspace):
     )
     assert disabled.returncode == 0
     assert work.render(ident, expected_revision=1)["status"] == "provider_unavailable"
+
+
+@pytest.mark.skipif(
+    os.environ.get("LOOPX_MEDIA_BLENDER_TEST") != "1",
+    reason="explicit optional Blender source qualification",
+)
+def test_real_blender_project_passes_reopen_and_http_download(http_workspace):
+    import io
+    import subprocess
+    import sys
+    import zipfile
+    from urllib.parse import urlencode
+    from PIL import Image, ImageChops
+
+    work, exchange = http_workspace
+    root, _, _ = _install_source_renderer(work)
+    plan = json.loads(
+        (root / "packages/loopx-media/examples/blender-handoff.json").read_text()
+    )
+    prepared = work.prepare(plan, source_directory=work.project)
+    ident = prepared["composition_id"]
+    ready = work.render(ident, expected_revision=1)
+    assert ready["status"] == "ready", ready
+    result = ready["result"]
+    assert result["qa"]["frames"] == 60
+    spatial = result["qa"]["blender_scenes"][0]
+    assert spatial["id"] == "route" and spatial["frames"] == 36
+    assert spatial["rgba_frames"] == spatial["depth_frames"] == 36
+    assert spatial["project_reopened"] is True
+    query = urlencode(
+        {
+            "goal_id": "media-demo",
+            "composition_id": ident,
+            "file": "blender-project.zip",
+        }
+    )
+    status, headers, data = exchange("GET", "/api/chat/content-media/file?" + query)
+    assert status == 200 and headers["Cache-Control"] == "no-store"
+    assert headers["Content-Type"] == "application/zip"
+    assert (
+        hashlib.sha256(data).hexdigest()
+        == result["files"]["blender-project.zip"]["sha256"]
+    )
+    directory = work.project / "independent"
+    directory.mkdir()
+    with zipfile.ZipFile(io.BytesIO(data)) as archive:
+        names = archive.namelist()
+        assert all(
+            not Path(name).is_absolute() and ".." not in Path(name).parts
+            for name in names
+        )
+        assert {
+            "scene-builder.py",
+            "plan.json",
+            "route.json",
+            "route/scene.blend",
+        } <= set(names)
+        for kind in ("rgba", "depth"):
+            assert (
+                len([name for name in names if name.startswith(f"route/{kind}/")]) == 36
+            )
+        (directory / "scene.blend").write_bytes(archive.read("route/scene.blend"))
+        with Image.open(
+            io.BytesIO(archive.read("route/rgba/frame-0019.png"))
+        ) as original:
+            original.load()
+            expected = original.copy()
+            assert original.mode == "RGBA" and original.getchannel(
+                "A"
+            ).getextrema() == (0, 255)
+        with Image.open(
+            io.BytesIO(archive.read("route/depth/frame-0019.png"))
+        ) as depth:
+            assert (
+                depth.size == (640, 360)
+                and depth.getextrema()[0] < depth.getextrema()[1]
+            )
+    # Independent consumer: open only the persisted blend, inspect real bpy
+    # state and re-render the middle frame without using the provider builder.
+    verified = subprocess.run(
+        [
+            sys.executable,
+            "-c",
+            """
+import bpy, json, pathlib, sys
+p = pathlib.Path(sys.argv[1])
+bpy.ops.wm.open_mainfile(filepath=str(p / 'scene.blend'), load_ui=False, use_scripts=False)
+s = bpy.context.scene
+assert s.render.engine == 'CYCLES' and s.render.fps == 12
+assert s.frame_start == 1 and s.frame_end == 36
+assert s.view_layers[0].use_pass_z and s.render.film_transparent
+assert len([o for o in s.objects if o.type == 'LIGHT']) == 2
+s.frame_set(1)
+assert abs(s.objects['artifact'].location.x + 2) < 0.0001
+camera_start = tuple(s.camera.location)
+s.frame_set(19)
+assert abs(s.objects['artifact'].location.x - 2) < 0.0001
+s.frame_set(36)
+assert abs(s.objects['artifact'].location.x + 2) < 0.0001
+assert tuple(s.camera.location) != camera_start
+s.frame_set(19)
+s.render.filepath = str(p / 'middle.png')
+for node in s.node_tree.nodes:
+    if node.type == 'OUTPUT_FILE':
+        node.base_path = str(p / 'depth')
+bpy.ops.render.render(write_still=True)
+(p / 'verified.json').write_text(json.dumps({'version': bpy.app.version_string, 'frame': s.frame_current}))
+""",
+            str(directory),
+        ],
+        capture_output=True,
+        text=True,
+        timeout=60,
+    )
+    assert verified.returncode == 0, verified.stderr[-2000:]
+    with Image.open(directory / "middle.png") as reopened:
+        assert ImageChops.difference(
+            expected, reopened.convert("RGBA")
+        ).getextrema() == ((0, 0), (0, 0), (0, 0), (0, 0))
+    assert json.loads((directory / "verified.json").read_text())["frame"] == 19
+    # Reuse is stateful and exact; it does not re-encode the same 3D scene.
+    attempt = work._record(ident)["attempt"]
+    assert work.render(ident, expected_revision=1)["status"] == "ready"
+    assert work._record(ident)["attempt"] == attempt

From 74db25c991afcf1563ccce37a0a69d7a6787e3b4 Mon Sep 17 00:00:00 2001
From: LoopX Agent <337587101+loopx-agent@users.noreply.github.com>
Date: Mon, 19 Oct 2026 16:57:58 +0800
Subject: [PATCH 8/9] fix(content-ops): refuse spatial body text before it can
 be lost

Signed-off-by: LoopX Agent <337587101+loopx-agent@users.noreply.github.com>
---
 .../protocols/content-ops-media-v0.md         |  7 +++
 .../capabilities/content_media.ts             |  1 +
 packages/loopx-media/README.md                |  6 +++
 .../loopx-media/src/loopx_media/renderer.py   |  2 +
 tests/control_plane_ts/content_media.test.ts  | 11 ++++
 tests/test_content_media.py                   | 51 +++++++++++++++++++
 6 files changed, 78 insertions(+)

diff --git a/docs/reference/protocols/content-ops-media-v0.md b/docs/reference/protocols/content-ops-media-v0.md
index 208def2046..85879e4aed 100644
--- a/docs/reference/protocols/content-ops-media-v0.md
+++ b/docs/reference/protocols/content-ops-media-v0.md
@@ -56,6 +56,13 @@ without changing that digest. A changed plan requires the expected revision
 and invalidates old content approval. Existing layout tokens are reused;
 static page-density rules do not certify a timed movie or its learning effect.
 
+`body` is supported for title and diagram shots. Excerpt and Blender layouts
+show a title and source boundary, and reject nonempty body text at admission
+and rendering. A qualifier must be retained in a supported visible field,
+separate title scene or timed caption; it must not silently disappear. Existing
+prepared spatial plans with nonempty body now fail explicitly and need a new
+revision that preserves that meaning in a supported field.
+
 ## Execution and readback
 
 ```sh
diff --git a/loopx/control_plane/capabilities/content_media.ts b/loopx/control_plane/capabilities/content_media.ts
index 36bb0a1473..3bebe3a355 100644
--- a/loopx/control_plane/capabilities/content_media.ts
+++ b/loopx/control_plane/capabilities/content_media.ts
@@ -118,6 +118,7 @@ export function validateMediaPlan(input: unknown) {
     if (kind !== "blender" && shot.scene !== undefined) fail("Scene geometry requires a Blender shot");
     const base = {id: token(shot.id), kind, seconds: number(shot.seconds, 1, 30), title: text(shot.title, 100),
       body: shot.body == null || shot.body === "" ? "" : text(shot.body, 300), source_ref: text(shot.source_ref, 240), boundary: text(shot.boundary, 180)};
+    if ((kind === "excerpt" || kind === "blender") && base.body) fail("Excerpt and Blender shots do not support body text; use a title, boundary or timed captions");
     if (kind === "blender") {
       fields(shot, ["id", "kind", "seconds", "title", "body", "source_ref", "boundary", "scene"]);
       const frames = number(base.seconds * fps, 12, 120, true);
diff --git a/packages/loopx-media/README.md b/packages/loopx-media/README.md
index 63d11a5420..880d512423 100644
--- a/packages/loopx-media/README.md
+++ b/packages/loopx-media/README.md
@@ -39,6 +39,12 @@ RTL shaping and arbitrary font discovery are not qualified. macOS speech is
 optional; other platforms require supplied audio or explicit silence.
 No cloud voice, generative image/video or game engine is bundled here.
 
+Excerpt and Blender layouts display the title and source boundary; nonempty
+`body` text is explicitly refused. Preserve a needed qualifier in those visible
+fields, a separate title scene or timed captions before preparing a new revision.
+The renderer also refuses a stale/direct request with unsupported body text;
+it cannot return ready while silently dropping that text.
+
 ## Optional Blender scenes
 
 For real 3D geometry, install the same provider with its optional Blender extra
diff --git a/packages/loopx-media/src/loopx_media/renderer.py b/packages/loopx-media/src/loopx_media/renderer.py
index 8b0db2e640..ce8c1b9662 100644
--- a/packages/loopx-media/src/loopx_media/renderer.py
+++ b/packages/loopx-media/src/loopx_media/renderer.py
@@ -120,6 +120,8 @@ def render(request: dict) -> dict:
     if request.get("protocol") != PROTOCOL:
         raise ValueError("Unsupported renderer protocol")
     plan, out = request["plan"], Path(request["attempt_directory"])
+    if any(shot["kind"] in {"excerpt", "blender"} and shot.get("body") for shot in plan["shots"]):
+        raise ValueError("The spatial layout does not support body text; revise the brief")
     out.mkdir(mode=0o700, exist_ok=False)
     started = time.monotonic()
     cancel = Path(request["cancel_file"])
diff --git a/tests/control_plane_ts/content_media.test.ts b/tests/control_plane_ts/content_media.test.ts
index 21390de3ca..9e411da2a9 100644
--- a/tests/control_plane_ts/content_media.test.ts
+++ b/tests/control_plane_ts/content_media.test.ts
@@ -85,6 +85,17 @@ test("caption admission preserves plain text and refuses structural paragraph se
 
 const spatialBrief = () => JSON.parse(readFileSync(new URL("../../packages/loopx-media/examples/blender-handoff.json", import.meta.url), "utf8"));
 
+test("spatial shots refuse body text instead of producing a movie that loses a qualifier", () => {
+  const excerpt = {...brief(), assets: [{id: "still", kind: "image", path: "source.png", sha256: "a".repeat(64), source_ref: "synthetic:still", visibility: "local_private"}],
+    shots: [{id: "view", kind: "excerpt", seconds: 6, title: "Source", asset_id: "still", source_ref: "synthetic:still", boundary: "Illustration"}]};
+  assert.equal(plan({plan: excerpt}).plan.shots[0]?.body, "");
+  assert.throws(() => plan({plan: {...excerpt, shots: [{...excerpt.shots[0], body: "IMPORTANT SYNTHETIC QUALIFIER"}]}}), /do not support body text/);
+  const blender = spatialBrief(); blender.shots[1].body = "IMPORTANT SYNTHETIC QUALIFIER";
+  assert.throws(() => plan({plan: blender}), /do not support body text/);
+  const title = brief(); title.shots[0] = {...title.shots[0], kind: "title", body: "A supported visible qualifier"};
+  assert.equal(plan({plan: title}).plan.shots[0]?.body, "A supported visible qualifier");
+});
+
 test("Blender scene geometry and camera belong to the same source-bound composition", () => {
   const raw = spatialBrief(), checked = plan({plan: raw});
   assert.equal(checked.frame_count, 60);
diff --git a/tests/test_content_media.py b/tests/test_content_media.py
index 2245f0e5f6..74227afd24 100644
--- a/tests/test_content_media.py
+++ b/tests/test_content_media.py
@@ -355,6 +355,33 @@ def _install_source_renderer(work):
     return root, command, state
 
 
+def test_spatial_body_refusal_creates_no_prepared_item(workspace):
+    work, _ = workspace
+    root = Path(__file__).resolve().parents[1]
+    plan = json.loads(
+        (root / "packages/loopx-media/examples/blender-handoff.json").read_text()
+    )
+    for kind in ("excerpt", "blender"):
+        invalid = deepcopy(plan)
+        invalid["shots"][1].update(kind=kind, body="IMPORTANT SYNTHETIC QUALIFIER")
+        if kind == "excerpt":
+            del invalid["shots"][1]["scene"]
+            invalid["shots"][1]["asset_id"] = "still"
+            invalid["assets"] = [
+                {
+                    "id": "still",
+                    "kind": "image",
+                    "path": "source.png",
+                    "sha256": "a" * 64,
+                    "source_ref": "synthetic:still",
+                    "visibility": "local_private",
+                }
+            ]
+        with pytest.raises(EffectRuntimeRejected, match="do not support body text"):
+            work.prepare(invalid, source_directory=work.project)
+    assert work.list()["compositions"] == []
+
+
 @pytest.mark.skipif(
     os.environ.get("LOOPX_MEDIA_RENDERER_TEST") != "1",
     reason="explicit optional local renderer qualification",
@@ -457,6 +484,30 @@ def test_real_optional_renderer_reuse_and_http_byte_readback(http_workspace):
         ],
     }
     prepared = work.prepare(second, source_directory=work.project)
+    # Actual provider boundary: a stale or direct caller cannot silently lose
+    # already-accepted text even if it bypasses current typed preparation.
+    from loopx.extensions.runtime import execute_extension_runtime_binding
+
+    record = work._record(prepared["composition_id"])
+    checked = media._owner("plan", {"plan": record["plan"]})
+    invalid = deepcopy(record["plan"])
+    invalid["shots"][0]["body"] = "IMPORTANT SYNTHETIC QUALIFIER"
+    refused = work.project / "refused-body"
+    with pytest.raises(RuntimeError):
+        execute_extension_runtime_binding(
+            work.binding().binding,
+            request={
+                "protocol": media.PROTOCOL,
+                "plan": invalid,
+                "layout_style": checked["layout_style"],
+                "plan_digest": record["plan_digest"],
+                "frame_count": record["frame_count"],
+                "sources": record["sources"],
+                "attempt_directory": str(refused),
+                "cancel_file": str(work.project / "not-cancelled"),
+            },
+        )
+    assert not refused.exists()
     rendered = work.render(prepared["composition_id"], expected_revision=1)
     assert (
         rendered["status"] == "ready"

From 036ddced0abf7dc9015469bc149b661f4170bf46 Mon Sep 17 00:00:00 2001
From: huangruiteng <huangrt01@163.com>
Date: Mon, 19 Oct 2026 17:41:03 +0800
Subject: [PATCH 9/9] docs(content-ops): include Blender in the shot contract

Signed-off-by: huangruiteng <huangrt01@163.com>
---
 docs/reference/protocols/content-ops-media-v0.md | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/docs/reference/protocols/content-ops-media-v0.md b/docs/reference/protocols/content-ops-media-v0.md
index 85879e4aed..d33d476a43 100644
--- a/docs/reference/protocols/content-ops-media-v0.md
+++ b/docs/reference/protocols/content-ops-media-v0.md
@@ -36,12 +36,13 @@ renderer repeats these format checks, escapes ordinary ampersands in VTT,
 and preserves plain text in SRT and the transcript. This bounded subset is
 qualified with the native browser track and real FFmpeg subtitle decoding.
 
-Shots are `title`, `diagram` (two to five `nodes`) or `excerpt` (image/video
-`asset_id` and optional `start_seconds`). These are composition-local rendering
-choices. They do not extend Goal/Todo state. Likewise prepared/rendering/ready/
-failed/cancelled/interrupted describe private render attempts, never published
-content or Agent liveness. An old saved running attempt is shown as interrupted
-after its bounded execution window; a read does not restart it.
+Shots are `title`, `diagram` (two to five `nodes`), `excerpt` (image/video
+`asset_id` and optional `start_seconds`) or `blender` (declarative `scene`
+geometry). These are composition-local rendering choices. They do not extend
+Goal/Todo state. Likewise prepared/rendering/ready/failed/cancelled/interrupted
+describe private render attempts, never published content or Agent liveness. An
+old saved running attempt is shown as interrupted after its bounded execution
+window; a read does not restart it.
 
 Preparation takes an explicit local source directory. Absolute paths,
 traversal, symlinks and wrong source digests are refused. The prepared record