diff --git a/.agent/skills/science-video-pipeline/SKILL.md b/.agent/skills/science-video-pipeline/SKILL.md
new file mode 100644
index 000000000..f219ea896
--- /dev/null
+++ b/.agent/skills/science-video-pipeline/SKILL.md
@@ -0,0 +1,32 @@
+---
+name: science-video-pipeline
+description: 把论文/综述做成动效图解科普视频的九阶段流水线（论文精读提取→策划→逐字稿 SSOT→双重校验→分镜→TTS 声音克隆→Remotion 场景实现→草渲抽帧 QA→终渲交付）。Use when producing or iterating a media/*-video/ episode: narration.md, storyboard.md, IndexTTS voice cloning, Remotion scenes, frame QA, or final render; or when scaffolding a new episode.
+allowed-tools: Read, Write, Edit, Glob, Grep, Bash
+---
+
+# 科普视频制作流水线（导航壳）
+
+本 Skill 是路由层：内容 SSOT 在 `media/pipeline/skills/01–09.md`，工具 SSOT 在
+`media/pipeline/scripts/`，不在此复制任何正文（防第二事实源）。
+
+## 九阶段速查
+
+| Stage | 做什么 | 规格链接 | 工具/命令（编排入口 `pipeline.py`） | 通过门 |
+|---|---|---|---|---|
+| ① 论文精读提取 | 并行子代理逐章 + 官方站点信源补充 | [01](../../../media/pipeline/skills/01-paper-extraction.md) | `paper_extract.py`（map/text/captions/find/render） | 全部断言可回溯；RISKY=0 |
+| ② 策划 | 受众/结构/视觉契约（色彩语义） | [02](../../../media/pipeline/skills/02-planning.md) | — | planning.md 六节齐 |
+| ③ 逐字稿 | narration.md ★单一事实源 | [03](../../../media/pipeline/skills/03-narration.md) | `pipeline.py build` | `build_narration.py` 通过 |
+| ④⑤ 双重校验 + 分镜 | 真实性回溯 + 易懂性；beat 覆盖性 | [04](../../../media/pipeline/skills/04-verification.md) / [05](../../../media/pipeline/skills/05-storyboard.md) | `pipeline.py check`（+`--check-scenes`） | RISKY=0；覆盖率无缺句 |
+| ⑥ TTS 配音 | 本人音色克隆（IndexTTS-2.5） | [07](../../../media/pipeline/skills/07-tts-voice.md) | `pipeline.py tts --plan` | refs 指纹门 + 试听 + ETA |
+| ⑦ Remotion 场景 | 代码动画实现 | [06](../../../media/pipeline/skills/06-remotion-implementation.md) | `tsc --noEmit` | 七条渲染红线 |
+| ⑧ 草渲 + 抽帧 QA | 半分辨率快速迭代 | [08](../../../media/pipeline/skills/08-render-qa.md) | `pipeline.py render` + `qa` | 自动体检零 FAIL |
+| ⑨ 终渲 + 交付 | 1080p30 + srt/vtt | [09](../../../media/pipeline/skills/09-final-render.md) | `render --final` + `captions` | 实测时长在预算窗 |
+
+## 关键不变量
+
+- 逐字稿只改 `narration.md`；`narration.json`/`manifest.json` 是派生物。
+- **口播永不出现他集标题与集数序号**——顺序只在视觉层与 [media/series.json](../../../media/series.json)（校验：`check_series.py`）。
+- 每集 `pipeline.toml` 是可执行参数的唯一来源；README 不复制命令行参数。
+- 时序常数只在 `video/src/timing.json`（timing.ts 与 Python 共读）。
+- 声音样本是生物特征：不入库（`voices/refs.toml` 只存指纹），试听后即删。
+- 新集脚手架与复用边界（Python 集中 SSOT / Remotion 复制不共享）见 [media/pipeline/README.md](../../../media/pipeline/README.md)。
diff --git a/.gitignore b/.gitignore
index 081e5beb9..f2fb968f7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -311,9 +311,11 @@ media/experience-era-agents-video/**/*.mp3
 media/experience-era-agents-video/**/*.wav
 
 # 声音克隆参考样本（media/pipeline/voices/）：个人声音属生物特征信息，绝不入库。
-# 目录级忽略 + README 白名单，防漏网音频格式（ogg/opus/wma 等）。
+# 目录级忽略 + 白名单例外（README 与 refs.toml 指纹清单——后者只存哈希与生成参数，
+# 不含音频字节），防漏网音频格式（ogg/opus/wma 等）。
 media/pipeline/voices/*
 !media/pipeline/voices/README.md
+!media/pipeline/voices/refs.toml
 
 # 科普视频工程（media/self-evolving-coding-agents-video）本地产物：同上集规则。
 media/self-evolving-coding-agents-video/video/public/audio/
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 1ad52650e..858dc0412 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -46,6 +46,18 @@ repos:
         files: ^apps/negentropy/
         types_or: [python, pyi]
 
+      # ── Python: media/pipeline（科普视频公共管线） ─────────────────────────
+      # 与 negentropy 同一 ruff 修订版；此前仅覆盖 apps/negentropy/，管线脚本无 lint 门
+      - id: ruff
+        name: ruff lint (media-pipeline)
+        args: [--fix, --exit-non-zero-on-fix]
+        files: ^media/pipeline/
+        types_or: [python, pyi]
+      - id: ruff-format
+        name: ruff format (media-pipeline)
+        files: ^media/pipeline/
+        types_or: [python, pyi]
+
   # ── Node.js: apps/negentropy-ui ──────────────────────────────────────────
   # ESLint v9 flat config（eslint.config.mjs），零警告策略（--max-warnings=0）
   - repo: local
@@ -106,3 +118,15 @@ repos:
         entry: uv run scripts/sync_versions.py check
         files: ^(VERSION|scripts/sync_versions\.py|package\.json|apps/negentropy/(pyproject\.toml|uv\.lock)|apps/negentropy-ui/package\.json|apps/negentropy-wiki/package\.json|apps/negentropy-perceives/(pyproject\.toml|uv\.lock)|packages/agents-chat-core/package\.json)$
         pass_filenames: false
+
+  # ── 科普视频系列一致性（media/series.json 执法） ─────────────────────────
+  # 规则：口播反串线（自身标题排除）/多标题顺序/序号绑定/清单完整性/相对链接死链。
+  # 注意：挂在内容修复之后落地；顺序调整类变更须先改 series.json 再动散文。
+  - repo: local
+    hooks:
+      - id: series-consistency-check
+        name: Series consistency (media/series.json)
+        language: system
+        entry: uv run --no-project media/pipeline/scripts/check_series.py
+        files: ^(media/|docs/\.agents/knowledge-map\.md|CHANGELOG\.md)
+        pass_filenames: false
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1bbe37ecd..0671a5353 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,16 +6,23 @@
 
 ### Added
 
+- **科普视频公共管线基建升级**：`pipeline.py` 单入口编排（status/doctor/build/check/tts/captions/render/qa/all/clean-samples，阶段契约与派生式新鲜度——零状态文件防第二事实源）+ 每集 `pipeline.toml` 声明式配置（可执行参数不再散落 README，治 ISSUE-161 类漂移）+ `timing.json` 时序常数 SSOT（timing.ts 同步 import、Python 侧 timeline.py 共读，双语言镜像漂移结构性消灭）+ 七件新工具：`check_script`（④⑤门：分镜覆盖性/时长预算双口径/淡入不变式/--check-scenes 分镜↔代码互比——当场抓出两集既存分镜漂移）、`check_series`（系列顺序五规则执法 [media/series.json](media/series.json)，自身标题排除使纯 grep 不可能做到的反串线 lint 成为可能）、`captions`（srt/vtt，cue 终点不含停顿）、`qa_frames --check/--check-theme`（黑帧/字幕带侵入[连通亮段法]/冻帧/字幕缺失 + WCAG 对比度）、`paper_extract`（Stage ① 取证五子命令）、`refs.py` + `voices/refs.toml`（参考样本指纹清单，只存哈希不存音频）、`tts.py --expect-ref-sha1` 指纹硬校验与 `.engine` 音色签名护栏 + `--allow-voice-switch` 显式放行（ISSUE-163 的拦截层）；`media/pipeline/tests/` 45 项（digest 黄金哈希守「缓存零失效」）全绿 2s；pre-commit ruff 扩至 `^media/pipeline/`；技能规格补齐 skills/07–09 并挂载路由型真 Skill [.agent/skills/science-video-pipeline](.agent/skills/science-video-pipeline/SKILL.md)（零正文复制）。
+- **系列发布顺序 SSOT 与 Remotion 最佳实践三集落地**：新增 `media/series.json`/`series.md`（三集顺序 + 「序号不进口播」系列纪律——发布顺序变更的 TTS 代价恒为零）；`@remotion/media` `<Audio>`（丢外层 Sequence + premountFor，渲染期自动关闭的事实写入注释）、`fitText` 字幕真实测量（替代手写 CJK 宽度估算与魔法阈值）、`SceneFade` 幕间呼吸淡入淡出（不用 TransitionSeries 的根因记录在案：Σ序列−Σ转场与绝对定位音频层不兼容）、`remotion.config.ts` 交付硬化（h264/crf18/yuv420p/aac192K/enforceAudioTrack；显式不设 concurrency——机器属性）；冻结文件三集 md5 唯一、根 lockfile 零变更；EP2/EP3 只同步不重渲（series.json status 标注窗口期）。
+
 - **声音克隆试听闭环：单句小样 + 情感三来源 + 样本选段勘探 + `sunny` 明快阳光预设**：此前管线只有工程级入口 `tts.py`（强依赖 `narration.json`），选样本/选风格却要等 2.5–3.5 小时的整集合成——新增 [`scripts/tts_sample.py`](media/pipeline/scripts/tts_sample.py) 直调服务合成单句（`--style` / `--all-styles` 全预设 A/B / `--dry-run` 秒级核参 / `--label` 横向对比 / `--play` 顺序试听），复用 `tts.py` 的风格预设与文本预处理故与成片同路径，单档暖机后约 20 秒。针对「五档预设都不够自然」的实测复盘，定位两个根因并各给工具：①**样本定基线**——新增 [`scripts/prospect_ref.py`](media/pipeline/scripts/prospect_ref.py) 按 F0 中位/四分位距/音节率/谱质心筛「更亮更轻快」的候选起点（成片原用样本综合分仅 157/275，换段即让克隆音高 +12~16%、起伏 +25~40%）；②**注入越多越假**——由上游混合式 `emovec = Σ(wᵢ·基向量ᵢ) + (1 − Σwᵢ)·参考音频情感` 推出「Σw 就是合成情感挤掉真实语调的比例」，故新增两条自然通路：`--emo-ref`（音色取 A、语调迁移自 B，零向量注入）与 `--emo-text`（QwenEmotion 把「轻快爽朗、自信阳光」转向量，按 ≤0.8 等比缩放并经 `X-Emo-Vector` 回显供固化），服务端新增 `--use-qwen-emo` 与 `/health.supports_emo_text`、对三来源显式互斥报错（上游对「向量+情感音频」是静默丢弃音频）。经 41 个候选小样试听定档 **`sunny`（明快阳光：happy 主载方向 + 有效注入 0.35 + df 0.95，配 `voices/me-bright.wav`）** 取代 `passionate` 成为科普长视频推荐位；并新增其定稿档 **`sunny-steady`（明快稳健）**——同方向同强度同语速、只把束宽提到 3，实测语调起伏 48.4 → 40–44 而亮度不掉（谱质心 1245 → 1214–1223），是唯一"不牺牲明快度就让语气更可信"的旋钮，代价是单句墙钟 20–35 秒 → 56–131 秒（整集 8–10 小时）。并配套 **`--steady` 混合档**（整集跑低束宽、仅冷开场/金句按 `--steady 'P0,p3-25b,p5-*'` 升到 3 束；选择器支持幕名/句 id/前缀通配，任一项匹配不到句子即报错以防拼错后静默降级）与 **`--plan` 排期预演**（纯本地算摘要，输出各束宽待合成/已缓存句数与长跑折算估时）——189 句一集实测：纯 sunny 2.9 h、升 5 句 3.1 h（+7%）、升 20 句 3.6 h（+24%）、整集升档 9.9 h（+241%），即每升 1 句约 +2.2 分钟。为此把**束宽提升为预设的一部分**（`STYLE_PRESETS` 可选键 `beams`，缺省 1；`--num-beams` 显式给值优先，其 argparse 默认值改为 `None` 以区分"没给"与"给了 1"），`--list-styles` 增列"有效注入/束宽"。[VOICE-CLONING.md](media/pipeline/VOICE-CLONING.md) 同步扩写：§三 增 3.3「样本决定基线」实测表、§四 增「情感三来源」对照与强度调参带（0.3–0.45 为自然平衡带）、§五 拆 5.1 小样试听/5.2 全量/5.3 重渲染并附纯 `curl` 直调、§六 摘要公式补 `|emoref=` / `|emotext=` 可选后缀（对已上线三集 189 句逐句核对摘要 100% 不变，存量缓存零失效）。
-- **自进化系列三集科普视频内容升级与本人音色克隆配音**：三集（[《AI 如何自己变强？》](media/self-improving-agents-video/README.md) v3 / [《上线之后，AI 才开始上学》](media/experience-era-agents-video/README.md) v2 / [《会写代码的 AI，开始给自己写代码》](media/self-evolving-coding-agents-video/README.md) v3）统一换用本人音色克隆配音（IndexTTS-2.5 `passionate` 激情风格，me-1.wav 样本经 RMS 预筛裁剪）；源论文第二遍重读校准（三集全部断言零事实漂移）+ 官方工程站点信源补充（ep1 312 条收录统计/九篇敲门砖→P5 活地图+卡片墙镜；ep2 经验编译器闭环/Gen3 适应面语义/SIP-Bench 四指标/111 篇×9 章→6-B2 闭环复盘+6-F 清单卡镜；ep3 无站点，SICA 三选择信号+Table 2 斜线规律两句锚定）；每集新增 `research/upgrade-2026-08.md` 审计文档（校准审计表+句级 delta+双重校验 delta RISKY/REWRITE=0+G2 验证记录）；动画增强（计数器滚动/环形图合拢/双色分拣重排/青紫双速差流光/斜线光带扫掠/检查点卡+四仪表/数值轨迹雷达/流光巡游，全部 skill-06 四红线合规）。
+- **自进化系列三集科普视频内容升级与本人音色克隆配音**：三集（[《上线之后，AI 才开始上学》](media/experience-era-agents-video/README.md) v2 / [《AI 如何自己变强？》](media/self-improving-agents-video/README.md) v3 / [《会写代码的 AI，开始给自己写代码》](media/self-evolving-coding-agents-video/README.md) v3，发布顺序见 [media/series.json](media/series.json)）统一换用本人音色克隆配音（IndexTTS-2.5 `passionate` 激情风格，me-1.wav 样本经 RMS 预筛裁剪）；源论文第二遍重读校准（三集全部断言零事实漂移）+ 官方工程站点信源补充（self-improving 312 条收录统计/九篇敲门砖→P5 活地图+卡片墙镜；experience-era 经验编译器闭环/Gen3 适应面语义/SIP-Bench 四指标/111 篇×9 章→6-B2 闭环复盘+6-F 清单卡镜——该 111 为未水合占位读数，后经 v3 重校准为数据文件口径 331/9，见 issue.md ISSUE-162；self-evolving-coding 无站点，SICA 三选择信号+Table 2 斜线规律两句锚定）；每集新增 `research/upgrade-2026-08.md` 审计文档（校准审计表+句级 delta+双重校验 delta RISKY/REWRITE=0+G2 验证记录）；动画增强（计数器滚动/环形图合拢/双色分拣重排/青紫双速差流光/斜线光带扫掠/检查点卡+四仪表/数值轨迹雷达/流光巡游，全部 skill-06 四红线合规）。
 - **科普视频管线新增「激情」配音风格预设与官方工程站点信源补充规范**：`media/pipeline/scripts/tts.py` 的 IndexTTS 风格预设表新增 `passionate`（充满激情与轻快：happy 0.70 主载高唤醒正价 + surprised 0.20 跳跃感 + calm 0.10 锚定咬字，有效和 1.00×0.7=0.70 ≤ 0.8 上限，语速 0.97 护密集技术句清晰度），`--list-styles` 与 [VOICE-CLONING.md](media/pipeline/VOICE-CLONING.md) §四 同步收录并给出科普长视频推荐位；[skills/01-paper-extraction.md](media/pipeline/skills/01-paper-extraction.md) 扩展「官方工程站点信源补充」纪律——只收事实性内容、逐字引用+URL+访问日期、落 `paper-notes.md` 末尾独立「信源补充」大节并与论文正文物理隔离、严禁下载/嵌入站点图片（概念转文字规格供 Remotion 代码动画重建）、站点信源单集专属不跨集。
 - **IndexTTS 推理束搜索宽度旋钮（`--num-beams`，长跑提速主开关）**：服务端 `tts_server.py` 请求模型与推理透传 num_beams（1–5），客户端 `tts.py` 新增 `--num-beams`（默认 1）；根因为 MPS fp32 实测每句墙钟 RTF 40–58（上游库内部 num_beams=3 使 GPT 段耗时按束宽线性放大），降为 1 束后 RTF≈12–15（采样生成下听感差异可忽略）；[VOICE-CLONING.md](media/pipeline/VOICE-CLONING.md) §4.3b 沉淀实测数据并修正原「每句 5–30 秒」的失实估计（整集实际数小时，需 nohup 后台+断点续跑）。
 
+- **《上线之后，AI 才开始上学》v3 重制交付（系列第一集）**：源论文第三遍重读校准（7 个按幕并行代理逐句审计，`paper_extract.py` 逐条取证）**确证并修复 3 处事实错误**——p0-01 Sutton 机构归属、p1-10「便宜一万倍」（论文全文无任何倍数，三查零命中）、p6-13a/b 站点「111 篇」（未水合 HTML 占位符，真实 331 篇/九章，见 ISSUE-162）；**5 处口径深化**——P3 补 Figure 8 二维地图（regime 是行×列分组，1↔2 分界是「改什么」）、P5 补第四类威胁与「对齐漂移」统摄透镜、环境天花板三轴、SIP-Bench 三分带（replay/adapt/held-out）、§10.2 晋升判准缺失（快慢双路之间的开关没有判准，本轮最高价值新增）。逐字稿 187 句（25 改写 + 8 新增，其余 154 句字节不变）；6 个新动画组件（VerificationBedrock/ThreeCurves/DriftLens/PromotionGate/EnvCeiling 三轴/Fig8 格阵 underlay）；**全片换用 `sunny-steady` 本人音色克隆重配**（me-bright.wav 一次命中 sha1 门，8 句领航形态试听通过），成片 14:01 · 1080p30 · h264/aac；质量门全绿（内容门 FAIL0/WARN0、系列一致性 FAIL0、抽帧体检 FAIL0、主题对比度 FAIL0）。
+
 ### Fixed
 
 - **`cli.sh restart` Phase 3 报 `PostgreSQL 未运行` 直接中止**：`postgresql@16` 非正常退出后数据目录残留 `postmaster.pid`（其 PID 被 OS 回收复用为他进程，本例为 WebKit），brew launchd 反复重试撞 `FATAL: lock file "postmaster.pid" already exists` → 服务进入 `error` 态，而 Phase 3（`cli.sh`）原先仅 `pg_isready -h localhost -p 5432` 探测一次、未运行即 `exit 1`，无自愈、不区分 PG 版本。根因实证：残留 pid 记录 PID `4174` 实为 `com.apple.WebKit.WebContent`（非 postgres），`/opt/homebrew/var/log/postgresql@16.log` 尾部 60+ 条同款 FATAL。修复：新增 `_ensure_postgres` 自愈链——解析 Homebrew formula（默认 `postgresql@16` 对齐 CI `pgvector:pg16`，按 `@16→@17→@18→postgresql` 探测，可 `NEGENTROPY_PG_FORMULA` 覆盖）→ `_clean_stale_pg_pid` 仅当 PID 已死或存活但非 postgres 进程时清理残留锁 → `brew services restart`（覆盖 error/已加载态，start 兜底）→ `_wait_pg_ready` 壁钟轮询就绪（默认 30s，`NEGENTROPY_PG_READY_TIMEOUT` 覆盖）；全失败才报错并附诊断（`brew services list` / 日志路径 / 版本核对）。无 `pg_isready` 时保留原「不探测、退由 alembic 校验」行为（最小干预）。新增 `scripts/tests/test_pg_selfheal.sh` 函数级回归测试（9 用例全通过）。本次即时清理 `@16` 残留锁并 restart 恢复，`SELECT version()` 核对为 16.14。防范：本机共存 PG@16/17/18，5432 易错位——残留 `postmaster.pid` 致 brew `error` 态是可复用判据，优先核 `ps comm` 而非 `kill -0`（后者对 OS 回收复用的 PID 误判存活）。
 - **Plan Review 人机交互断链根治 + 一核五翼 Faculty 真实答问（实证 Routine 77c8a8b6）**：巡检 Routine 的 Plan Review 回路断裂——CC 经 `AskUserQuestion` 提交方案后收到 `<error>Answer questions?</error>`、困惑重试空耗 turns，NegentropyEngine（元神）的 refine 反馈虽产出（事件流可见 3 次 `plan_review`）却从未送达 CC。根因：`orchestrator._build_config` 的 unified plan 段仅在 `plan_review_via_hook=True` 时挂 PreToolUse 钩子，而巡检默认 `False` → 回退到 reader clean stdin 路径，但 headless `claude -p` 下 `AskUserQuestion` 的 stdin tool_result **从始无效**（ISSUE-123 实验结论）；历史注释「clean stdin 经 19 例 ExitPlanMode 应答证明可用」混淆了 ExitPlanMode（stdin 可用）与 AskUserQuestion（stdin 无效，而 PLAN prompt 恰约束 CC 用后者提交）。**修复（PR 2a）**：unified plan 段**无条件挂 PreToolUse 钩子**（不再受 per-routine `via_hook` 控制——plan 段评审是引擎核心机制、headless 下唯有钩子可工作），并强制 `plan_config.auto_answer_context.plan_review_via_hook=True` 令 reader 跳过失效 stdin；修正 `orchestrator`/`patrol_prompt` 的错误注释。refine 反馈经钩子 `deny+reason` 同轮回灌 CC，CC 据此修订重提或按 approve 结束本轮。**FacultyBridge 真实答问（PR 2b）**：`_auto_answer_question`（INJECT-4）开启 `faculty_bridge_enabled` 时经 ADK Runner 同步调用**真实本心（Internalization）Faculty** 产出答复，失败/超时降级 litellm（与 INJECT-2 Plan 审 / INJECT-5 评估的元神调用同范式）。INJECT-3 门控为确定性子进程执行、无 LLM 接缝，保留 `action`（妙手）归因不强插 Faculty（最小干预）。
 - **`cli.sh restart` 报 `Can't locate revision identified by '0078'`**：共享 `negentropy` dev DB 的 `alembic_version` 被超前 stamp 到 `0078`（`routine_iteration_events.agent_role` 列），但 `cli.sh` 从部署分支 `feature/1.x.x`（迁移树 head 仅到 `0077`）跑 alembic 时无法在自身树中定位 `0078`。根因是工作区（带未合并 PR #1013 的 migration 0078）曾以无效 env override 跑 alembic roundtrip——`NE_DATABASE__NAME` 并非 `DatabaseSettings` 真实字段，未重定向到临时库、实际落到共享 `negentropy` DB。修复：从工作区执行 `0078` 的 `downgrade()`（drop 空 `agent_role` 列，核查 113550 行该列 0 非空、零数据损失）realign DB 到 `0077`，与部署分支 head 对齐；前向安全已验证（`0077→0078` 幂等重应用，PR #1013 合并后自动复用）。防范：迁移测试须用真实 settings 字段或独立 DSN 重定向，勿依赖未映射的 env key。
+- **修复 7 处文档死链**：三集 README 的 `../../pipeline/VOICE-CLONING.md` 实际解析到仓库根（正确为 `../pipeline`）、`media/pipeline/README.md` 与 `docs/.agents/knowledge-map.md` 的 video-package 残留（commit f7d72814 漏改）、skills/03 模板占位链接。
+- **修复两集分镜表既存漂移**（check_script 新门禁首个实证）：EP1 的 0-D 区间与 P2 镜号字母错位（qa_frames 镜号核对对 P2 失真）；EP2 的 7 句失覆盖与 2-B/2-D/2-H 三镜未随代码拆行。
 
 ### Changed
 
diff --git a/docs/.agents/issue.md b/docs/.agents/issue.md
index 6ed3a9258..fce739de3 100644
--- a/docs/.agents/issue.md
+++ b/docs/.agents/issue.md
@@ -3507,3 +3507,26 @@ R7 后浏览器对照 Section 2.1 区域发现两类正交缺陷：
 - **后续防范**：① **新增 `urlopen`/`urlretrieve` 等 B310 家族调用必须同步附 `# nosec B310` + 理由**——在无 `[tool.bandit]` 配置、闸门依赖逐行豁免的仓库里，任何未豁免的 Medium+ 发现都会红灯；`# nosec` 注释须落在 bandit 报告的**确切行号**（多行调用取起始行）。② URL 拼接优先约束受信来源（内部常量 / 配置注入），把「豁免理由真实可辩护」作为提交前自检项。③ **routine 自动生成的 PR 若引入新第三方/标准库调用，须过一遍 SAST 闸门**——本文件由 pdf-fidelity-patrol routine 产出，生成侧无 bandit 意识，人工兜底不可省。
 - **同类问题影响**：所有 perceives 内经 `urllib`/`subprocess`/`random` 等 bandit 黑名单 API 的新代码，均须遵循逐行 `# nosec` + 理由约定；其它子应用若同样无 `[tool.bandit]` 配置，须比照办理。改动文件：`apps/negentropy-perceives/src/negentropy/perceives/tools/patrol_verify_fidelity.py`（+2 行注释）。
 - **连带效应（bandit 放行后暴露 pip-audit）**：本次 bandit 转绿后，同 `Security Audit` job 的 `pip-audit` 步骤首次得以执行，暴露 15 条既存依赖 advisory（advisory DB 增补，非本 PR 引入）。该 pip-audit 复发按其归属统一记于 [ISSUE-092 的 2026-07-20 复发增补](#issue-092-perceives-security-audit-因-pysec-数据库增补-21-条新告警致-pip-audit-退出-12026-05-20)（升级 4 包 + ignore transformers/setuptools 各 1 条），同 PR #1093 一并处理，避免同 Issue 多处维护。
+
+## ISSUE-161 科普视频管线配置漂移：分集 README 复现命令与推荐位分叉，照跑即作废整集声纹缓存（2026-08-19）
+
+- **表因**：三集 README 的复现命令写 `--style passionate --ref …/me-1.wav`，而 [VOICE-CLONING.md](../../media/pipeline/VOICE-CLONING.md) §5 推荐位已迁至 `sunny`/`sunny-steady` + `me-bright.wav`（PR #1107）——文档间口径分叉且无任何机制提示。
+- **根因**：**无分集声明式配置**。可执行参数以复制粘贴形式散落三份 README，推荐位一迁移，旧命令全部变成「合法但错误」——`{id}.mp3` 单槽位 + 摘要含 style/ref_sha1（tts.py `digest_indextts`），照旧命令跑会把整集克隆音频静默改写成 deprecated 风格（179–228 句、数小时级返工）。
+- **处理方式**：① 每集新增 `pipeline.toml`（episode/narration/tts/render 四节）作为可执行参数唯一来源，README 只留 `pipeline.py tts` 一行；② `pipeline.py` 编排入口从配置装配参数并自动带 `--expect-ref-sha1` 指纹硬校验；③ 新增 `.engine` 音色签名标记 + `--allow-voice-switch` 显式放行（含 `--plan` 路径前置，排期阶段即拦截误重录）；④ `refs.py` + `voices/refs.toml` 指纹清单（只存哈希与生成参数，.gitignore 白名单例外放行）。见 [pipeline README](../../media/pipeline/README.md)。
+- **后续防范**：**可执行参数不落散文文档，文档只引用配置**。任何「文档里手写命令行参数」的流水线都有同款漂移面；评审时见到 README/文档内联长命令行（含风格/样本/版本等会变参数）应要求收敛到声明式配置。
+- **同类影响与注意**：本类漂移在「推荐位会迁移」的领域（模型档位、样本、API 版本）必然复发；修复时务必同时上「拦截层」（签名/指纹硬失败）而不只改文档——文档改对了，下一次迁移照样分叉。
+
+## ISSUE-162 站点数字取自未水合 HTML 源码，把占位符写进口播（111 vs 331）（2026-08-19）
+
+- **表因**：第一集口播 p6-13a 说配套仓库「收录了**一百一十一篇**论文」、p6-13b 九章含「工具」「定义」两章——与真实数据（331 篇/330 唯一 id；九章为 引言/Harness/技能/记忆/环境/RL 与持续学习/元进化/评测/安全）不符。
+- **根因**：官方站点 `index.html:57` 的 `<dt id="stat-papers">111</dt>` 是**未水合占位符**，`app.js:333` 实际执行 `els.statPapers.textContent = String(papers.length)`（真实访客看到 331）；上一轮信源补充把 **HTML 源码当渲染结果读**，占位数字进入口播；九章清单则是基于占位数字的**推断**而非站点原文（`data/manuscript.json` 的 chapterOrder 才是权威）。旁证：`DEV_LOG.md` 明写 "331-paper data set unchanged"、`index.html` 加载 `papers.js?v=links-331`。取证链见 [paper-notes.md](../../media/experience-era-agents-video/research/paper-notes.md)「2026-08 v3 重读校准」节。
+- **处理方式**：口播改「三百多篇」约数 + 画面标精确值 331 与取数日期（活数据说死数字到发布必陈旧）；paper-notes 记全取证链；九章按章序用片中已教过的词重写。
+- **后续防范**：**站点数字只能取自数据文件（JSON/CSV 端点）或水合后 DOM，绝不取 HTML 源码**；静态抓取（curl/gh api/wget）拿到的一切统计数字都应视为占位符直至与数据文件互证。同批连带教训：正文引用年份 ≠ 事件纪年（ClawHavoc [Jiang et al., 2026b] 是引用年）；统计单位口径以原文为准（>90% 的单位是 trials 不是场景）。
+- **同类影响与注意**：凡「官方工程站点信源补充」（skills/01 规范）都适用；提取数字时优先找 `/data/*.json` 类端点或页面脚本里的赋值语句。
+
+## ISSUE-163 tts.py 漏写 --engine indextts 会静默用预置音色覆写整集克隆音频（2026-08-19）
+
+- **表因**：`tts.py` 对克隆专属参数（--ref/--style 等）在 edge 引擎下只打 stderr「提示后忽略」并照常合成。
+- **根因**：`{id}.mp3` 单槽位 + 摘要不含引擎标识——换引擎=每句摘要都「合法地」变了，逐句 sidecar 察觉不到「整集正在被换音色」；且硬化不对称：`--plan` 路径已按同一危害论证改为硬失败（tts.py:605-612 注释写明），**合成路径漏了同样的处理**。
+- **处理方式**：带值克隆参数（--ref/--style/--lang/--emo-*/--duration-factor/--num-beams/--steady）在 edge 下 `parser.error` 硬失败（典型手型=「照抄文档打了 --ref/--style 却丢了 --engine」）；`.engine` 音色签名标记作第二层（覆盖「一个参数都没打」的场景），不一致须 `--allow-voice-switch`。测试 `test_engine_guard.py` 六个用例锁定行为。
+- **后续防范**：**破坏性默认值必须硬失败而非提示**——静默降级的输出会覆盖唯一产物槽位时尤甚；修一处同类风险要横向扫全部入口（plan/合成/编排三层当时只硬化了一层）。
diff --git a/docs/.agents/knowledge-map.md b/docs/.agents/knowledge-map.md
index 6be36de58..60acd5ba0 100644
--- a/docs/.agents/knowledge-map.md
+++ b/docs/.agents/knowledge-map.md
@@ -70,6 +70,7 @@
 - [自进化 Agents Team 调研](../research/self-evolution/130-self-evolving-agents-team.md) — 自进化智能体理论（DGM/ADAS/AlphaEvolve/AgentSquare）+ 进化算子（GEPA/ACE/DSPy）+ 评测回路（Agent-as-a-Judge/OTel/Langfuse）+ 工具生态自进化（MCP Registry/Agent Skills/LLM 自造工具）+ 记忆/知识系统自进化（MemGPT/Mem0/A-Mem 自编辑记忆、ReasoningBank/Memp 经验沉淀、MemEvolve/MemSkill 记忆元进化、Zep/HippoRAG 2 图谱记忆、SSGM/MINJA 记忆治理）+ 护栏治理（OWASP Agentic Top 10/金丝雀/Goodhart 防护），映射至四层自进化架构（技术方案见 [自进化 Agents Team 方案](../concepts/design/self-evolving-agents.md)）
 - [经验时代的自驱迭代进化智能体调研](../research/self-evolution/140-experience-era-self-improvement.md) — 精读 88 页综述提炼 Harness 经验基础设施框架，对照 negentropy Routine 闭环诊断出两处根本断点（Judge 无历史锚点 ±20 振荡 / `decay_override` 死配置致经验记忆 7-8 天全灭 + 反馈链断），落地双支柱改进：证据锚定纵向评估（trajectory + progress_evidence + 量化振荡 opt-in）与经验记忆闭环补强（衰减修复 E / 检索反馈闭环 B / 写入去重准入 A / 失败教训结构化与注入 C-D）
 - [Skill 进化闭环 × 自我改进评测](../research/self-evolution/141-skills-evolution-and-si-measurement.md) — 综述 §3（Skills 三阶段 Evolution 缺口）/ §7（Meta-Evolving 三体制）/ §8（SI 六目标 + SIP-Bench + 反事实归因）映射到 negentropy：PR [#1038](https://github.com/ThreeFish-AI/negentropy/pull/1038) 落地 eval 四表 + held-out 双相门（decide_skill_shadow/canary）+ 反事实 Skill Influence Pattern + TargetHandler 抽象 + SkillTemplateHandler 闭环（GEPA 变异 prompt_template + active_version 发布），补 140 号未覆盖的 Skills/Meta/SI 度量框架
-- [arXiv §5 科普视频制作包](../../video-package/README.md) — 基于 [141 号调研同源综述](../research/self-evolution/141-skills-evolution-and-si-measurement.md)（arXiv:2607.13104 §5 基座模型自我改进）的完整视频制作包：13:42 逐字稿（N0–N6 段落 ID 主键体系，4.7 字/秒自洽）+ 46 镜头分镜表（md/csv 双格式，822s 与逐字稿/动画三表对齐）+ 单文件 Canvas 动画 demo（1920×1080、8 场景 3B1B 风格、←/→/空格/R/1-8/H 快捷键、file:// 零依赖直开）+ 71 条事实核查表（引文 100% grep 验证命中论文原文、RISKY/REWRITE 双零、ANALOGY 类比显式登记）
-- [科普视频制作 Pipeline（公共基建）](../../media/pipeline/README.md) — 全仓可复用的论文→视频九阶段流水线（精读提取含官方工程站点信源补充/策划/逐字稿 SSOT/双重校验/分镜/TTS/Remotion/抽帧 QA/终渲）：中心脚本三件套（`--project` 参数化）+ 每 Stage 代理提示词规格（skills/01–06：01–05 内容层 + 06 生产层 Remotion 实现）+ 新集脚手架清单与复用边界（Python 脚本集中 SSOT、Remotion 原语复制适配）；作品：[《AI 如何自己变强？》](../../media/self-improving-agents-video/README.md)（Schmidhuber 综述 · 蓝/橙契约 · 6 幕）、[《上线之后，AI 才开始上学》](../../media/experience-era-agents-video/README.md)（[140 号调研](../research/self-evolution/140-experience-era-self-improvement.md)同源清华×Frontis 综述 · 金/青/紫契约 · 7 幕 13.6 分钟）与 [《会写代码的 AI，开始给自己写代码》](../../media/self-evolving-coding-agents-video/README.md)（arXiv:2608.03392 NJUST×NJU 综述 · 终端绿/洋红契约 · 7 幕 14.7 分钟，五对象×时机证据×可信进化，论文笔记由 8 并行代理逐章精读产出）；配音支持用自己的声音克隆（明快阳光 sunny 推荐位 + 激情/轻快/自信/正能量，另有语调迁移 `--emo-ref` 与自然语言 `--emo-text` 两条情感通路；单句小样试听 `tts_sample.py`、样本选段勘探 `prospect_ref.py`，见 [VOICE-CLONING.md](../../media/pipeline/VOICE-CLONING.md)；2026-08 三集统一换用本人音色 passionate 风格 + 内容升级审计文档 [upgrade-2026-08.md](../../media/self-improving-agents-video/research/upgrade-2026-08.md) 各集一份，站点信源补充规范沉淀于 skills/01）
+- [科普视频制作 Pipeline（公共基建）](../../media/pipeline/README.md) — 全仓可复用的论文→视频九阶段流水线：`pipeline.py` 单入口（status/doctor/build/check/tts/captions/render/qa/all）+ 每集 `pipeline.toml` 声明式配置 + `timing.json` 时序 SSOT（timing.ts 与 Python 共读，双语言镜像漂移结构性消灭）；技能规格 skills/01–09（01–05 内容层、06 生产层实现、07 TTS、08 草渲 QA、09 终渲交付），真 Skill 挂载于 [.agent/skills/science-video-pipeline](../../.agent/skills/science-video-pipeline/SKILL.md)（纯路由壳）；测试 `media/pipeline/tests/` 45 项（digest 黄金哈希守缓存零失效）；工具：check_script（分镜覆盖性/时长预算双口径）、check_series（系列顺序五规则执法 [series.json](../../media/series.json)）、captions（srt/vtt）、qa_frames --check（黑帧/字幕带侵入/冻帧/WCAG 对比度自动体检）、paper_extract（论文取证五子命令）、refs（样本指纹清单）。
+- [自进化系列科普视频 · 三集作品](../../media/series.md) — 发布顺序《上线之后，AI 才开始上学》（金/青/紫，EP1，v3 已交付：内容校准 + sunny-steady 重配，成片 14:01）→《AI 如何自己变强？》（蓝/橙，EP2）→《会写代码的 AI，开始给自己写代码》（绿/洋红，EP3）；系列纪律：口播永不携带他集标题与集数序号，顺序变更 TTS 代价恒为零；各集 research/paper-notes.md 为口播单一事实源、upgrade-*.md 为轮次审计记录。
+- [IndexTTS 声音克隆手册](../../media/pipeline/VOICE-CLONING.md) — 双引擎 TTS 的克隆侧单一参考：部署（~/tools/index-tts 服务）/参考样本（prospect+prepare+refs 指纹门）/风格预设（sunny 明快阳光推荐位、sunny-steady 成片档 beams=3）/试听关卡（tts_sample + 领航片段）/缓存摘要与幂等/许可合规。
 - [自进化 Agents Team 方案（Phase 3 记忆检索面已落地）](../concepts/design/self-evolving-agents.md) — 四层自进化架构：本次落地 `engine/evolution/` 子系统（GEPA proposer + 状态机 + decision 护栏）并在记忆检索权重面接通 propose→shadow→canary→promote/rollback 全闭环（迁移 0081 + evolution_inspector），默认全关灰度；agent/skill/knowledge 面、Phase 1 tool_invocations 遥测、eval 四表留后续
diff --git a/media/experience-era-agents-video/README.md b/media/experience-era-agents-video/README.md
index 494acb8c5..7b32d0958 100644
--- a/media/experience-era-agents-video/README.md
+++ b/media/experience-era-agents-video/README.md
@@ -1,9 +1,20 @@
 # 《上线之后，AI 才开始上学》科普视频工程
 
-> 基于 Che Jiang, Jincheng Zhong, Yu Fu, *et al.*, "Self-Improving Agents in the Era of Experience: A Survey of Self- to Meta-Evolution," *Frontis.AI / Tsinghua University*, Jun. 2026（88 页综述，无公开 arXiv 号）的动效图解式科普视频（B 站/YouTube，约 13.6 分钟）。
-> 形态：**本人音色克隆配音**（IndexTTS-2.5，passionate 激情风格）+ Remotion 代码动画，无真人出镜。
+> 基于 Che Jiang, Jincheng Zhong, Yu Fu, *et al.*, "Self-Improving Agents in the Era of Experience: A Survey of Self- to Meta-Evolution," *Frontis.AI / Tsinghua University*, Jun. 2026（88 页综述，无公开 arXiv 号）的动效图解式科普视频（B 站/YouTube，约 14 分钟）。
+> 形态：**本人音色克隆配音**（IndexTTS-2.5，sunny-steady 明快稳健成片档，me-bright.wav 样本）+ Remotion 代码动画，无真人出镜。
 > （v2 前为 edge-tts 预置音色，两种引擎 manifest 契约一致，可随时切回。）
-> 与上一集《AI 如何自己变强？》（[../self-improving-agents-video/](../self-improving-agents-video/README.md)，Schmidhuber 团队综述）互补：上集讲「自我进化改什么」，本集讲「部署之后经验怎么攒」；片尾互相引用。
+> 三集系列第 1 集（各集独立成片，口播不出现他集标题与集数序号）；同系列：[《AI 如何自己变强？》](../self-improving-agents-video/README.md)（自我进化改什么）、[《会写代码的 AI，开始给自己写代码》](../self-evolving-coding-agents-video/README.md)（代码领域全图），发布顺序见 [../series.json](../series.json)。
+
+## 交付状态（v3，2026-08-20）
+
+| 项 | 值 |
+|---|---|
+| 成片 | `out/final.mp4` · 14:01 · 1920×1080@30 · h264/yuv420p · aac 189kb/s |
+| 配音 | IndexTTS-2.5 本人音色克隆 · `sunny-steady`(beams=3) · `me-bright.wav`(sha1 54b699cce97f) |
+| 逐字稿 | 187 句 / 3884 字（v2→v3：25 改写 + 8 新增，其余 154 句字节不变） |
+| 字幕 | `out/captions.srt` + `.vtt`（187 cues） |
+| 质量门 | 内容门 FAIL0/WARN0 · 系列一致性 FAIL0 · 抽帧体检 FAIL0 · 主题对比度 FAIL0 |
+| 审计 | [upgrade-2026-08-v3.md](./research/upgrade-2026-08-v3.md)（含 3 处事实错误的取证与修复记录） |
 
 ## 目录结构
 
@@ -14,6 +25,7 @@
 | `script/narration.md` | 逐字稿（唯一维护处），`- [句id] 文本` 一句一行 |
 | `script/narration.json` | 派生物：拆句结果，供 TTS 与字幕消费（勿手改） |
 | `script/storyboard.md` | 分镜表：镜号 ↔ 句 id 区间 ↔ 画面动效（场景组件实现规格） |
+| `pipeline.toml` | 本集管线配置（配音/渲染/时长预算）——`pipeline.py` 的参数源 |
 | `scripts/*.py` | 薄包装 → 公共管线 [media/pipeline/scripts/](../pipeline/scripts/)（`--project` 透传） |
 | `video/` | Remotion 工程（独立 pnpm 项目，`ignore-workspace` 与主仓隔离） |
 | `out/` | 渲染产物（gitignored） |
@@ -24,10 +36,9 @@
 # 1. 改稿后重建逐句 JSON
 uv run --no-project scripts/build_narration.py
 
-# 2. 合成配音（本人音色克隆，增量幂等；需先启动 IndexTTS 服务，见 ../../pipeline/VOICE-CLONING.md）
-uv run --no-project --with mutagen scripts/tts.py --engine indextts \
-    --ref <仓库绝对路径>/media/pipeline/voices/me-1.wav --style passionate
-#    （声音样本不入库：me-1.wav 需从本人录音经 prepare_ref.py 裁剪生成；整集约数小时，断点续跑）
+# 2. 合成配音（本人音色克隆，增量幂等；参数读自本集 pipeline.toml——成片档 sunny-steady，草稿遍加 --style sunny；
+#    需先启动 IndexTTS 服务，见 ../pipeline/VOICE-CLONING.md）
+uv run --no-project ../pipeline/scripts/pipeline.py --project . tts
 
 # 3. 预览
 cd video && pnpm install --ignore-workspace && pnpm dev
@@ -58,4 +69,4 @@ cd video && pnpm run render               # -> ../out/final.mp4
 
 ## 许可注意
 
-Remotion 对超过 3 人的公司需商业授权（个人/小团队免费）；若本视频转为公司用途，请评估许可或迁移 MIT 协议的 Motion Canvas。配音为**本人声音的自愿克隆**（IndexTTS-2.5，按 bilibili 模型使用许可：个人/研究用途可用，商用需联系 indexspeech@bilibili.com；克隆他人声音须获本人书面同意，详见 [../../pipeline/VOICE-CLONING.md](../../pipeline/VOICE-CLONING.md) §八）。发布前请自行确认平台对合成语音的标注要求。
+Remotion 对超过 3 人的公司需商业授权（个人/小团队免费）；若本视频转为公司用途，请评估许可或迁移 MIT 协议的 Motion Canvas。配音为**本人声音的自愿克隆**（IndexTTS-2.5，按 bilibili 模型使用许可：个人/研究用途可用，商用需联系 indexspeech@bilibili.com；克隆他人声音须获本人书面同意，详见 [../pipeline/VOICE-CLONING.md](../pipeline/VOICE-CLONING.md) §八）。发布前请自行确认平台对合成语音的标注要求。
diff --git a/media/experience-era-agents-video/pipeline.toml b/media/experience-era-agents-video/pipeline.toml
new file mode 100644
index 000000000..e8df451a6
--- /dev/null
+++ b/media/experience-era-agents-video/pipeline.toml
@@ -0,0 +1,24 @@
+# 《上线之后，AI 才开始上学》管线配置——pipeline.py 的默认参数源。
+# 可执行参数只落此处，README 不再复制粘贴命令行（防 ISSUE-161 类漂移）；
+# CLI 显式参数仍可覆盖本文件。
+
+[episode]
+slug  = "experience-era-agents-video"
+title = "上线之后，AI 才开始上学"
+
+[narration]
+# 时长预算门（check_script.py 两口径都查：字数估算 + manifest 实测）
+target_minutes = [13.0, 14.2]
+chars_per_min  = 280        # 与 build_narration.py 既有估算口径一致
+
+[tts]
+engine   = "indextts"
+ref      = "media/pipeline/voices/me-bright.wav"   # 仓库根相对
+ref_sha1 = "54b699cce97f"                          # --expect-ref-sha1 硬校验（12 位，同 tts.py 口径）
+style    = "sunny-steady"   # 2026-08 重录决策：成片档 beams=3（首集全片换 sunny-steady）
+lang     = "ZH"
+# 两遍法：草稿遍用 CLI 覆写 --style sunny（快 3.4 倍），定稿遍回到本配置默认值。
+
+[render]
+draft_scale        = 0.5
+draft_jpeg_quality = 60
diff --git a/media/experience-era-agents-video/research/paper-notes.md b/media/experience-era-agents-video/research/paper-notes.md
index 91f058eb8..5378a2b4a 100644
--- a/media/experience-era-agents-video/research/paper-notes.md
+++ b/media/experience-era-agents-video/research/paper-notes.md
@@ -5,7 +5,7 @@
 > **用途**：本笔记是科普视频《经验时代》的**单一事实源**——逐字稿中的每个论文断言必须能回溯到本文件的对应条目。
 > **提取方式**：2026-08-16 由 9 个并行提取代理对论文 PDF 全文逐节精读产出（§1–2、§3、§4、§5、§6、§7、§8、§9、§10 各一代理）。
 > **交叉引用**：工程向应用调研见 [docs/research/self-evolution/140-experience-era-self-improvement.md](../../../docs/research/self-evolution/140-experience-era-self-improvement.md)（同一论文映射到本仓 Routine 闭环的双支柱改进）。
-> **与本系列上一集的关系**：上一集《AI 如何自己变强？》依据的是 Schmidhuber 团队综述（arXiv:2607.13104，聚焦“自我进化改什么：大脑 θ / 装备 Σ”）；本集论文聚焦“部署之后经验如何变成实力”（Harness=经验基础设施、trace→经验、四代更新面、元进化、SI 评测、移动攻击面）。两篇互补：上一集回答“改哪”，本集回答“上线之后怎么攒”。
+> **与同系列另两集的关系**（事实追溯用，非串线依据）：《AI 如何自己变强？》依据 Schmidhuber 团队综述（arXiv:2607.13104，聚焦“自我进化改什么：大脑 θ / 装备 Σ”）；本集论文聚焦“部署之后经验如何变成实力”（Harness=经验基础设施、trace→经验、四代更新面、元进化、SI 评测、移动攻击面）。两篇互补：一篇回答“改哪”，本集回答“上线之后怎么攒”。各集独立成片、口播互不引用（发布顺序见 [../../series.json](../../series.json)）。
 
 ---
 
@@ -909,30 +909,51 @@
 - 四指标原文：held-out gain（"does experience improve performance on tasks outside the adaptation stream?"）；backward retention（"does the same evolving agent keep old capabilities after updating?"）；path attribution（"did the gain come from skills, memory, tools, parameter updates, or their interaction?"）；efficiency/safety（"was the gain worth its cost and risk?"）。
 - 站点动机句："Without longitudinal evaluation, we cannot tell durable self-improvement from one-off elicitation, overfitting, drift, or unsafe mutation."
 
+### 官方站点 8 图 = 论文原图的逐字 caption（动画规格权威依据）
+
+> gh-pages `index.html` 的 alt 文本证实每张 PNG 均 "rendered from the LaTeX-referenced *X* PDF"——站点图就是论文自己的图。skill-01 规范「不下载图片、转文字规格」据此完全可行：caption + 精读笔记描述 + 本地 PDF 光栅化参考（`out/figs/`，不入库）三源合一。
+
+| 站点图 | 论文图 | caption 逐字（截要） |
+|---|---|---|
+| harness | Fig 2 (p7) | "The user side U_t supplies goals, instructions, preferences, approvals, and corrections, while the environment side E_t supplies executable state, observations, tests, and verifiable feedback. The harness H_t mediates context, action routing, per…" |
+| timeline | Fig 3 (p8) | "From Gen 1 to Gen 3, the main object shifts from episodic tool use, to cross-task memory and workflow structuring, to persistent harness-centered runtimes whose adaptation surfaces can evolve after deployment." |
+| skill | Fig 4 (p13) | "Skill Creation adds externally produced skills to the bank; Skill Use organizes, retrieves, composes, and executes the current bank; Skill Evolution converts compiled deployment experience into updates…" |
+| memory | Fig 5 (p20) | "Memory representations define what is stored, memory operations decide how stored information is written, compressed, retrieved, updated, and reintroduced into active context, and memory evolution captures…" |
+| environment | Fig 6 (p26) | "A deployed agent can improve through prompting, memory, skills, and harness-side control only within the executable world exposed by the environment. Raising the practical ceiling therefore requires richer action surfaces, denser observations and fee[dback]…" |
+| parameter-path | Fig 7 (p32) | "Stable runtime priors first accumulate in harness-side artifacts and interaction traces; the parameter path consolidates selected lessons into model updates that reduce repeated context orchestration, transfer beyond context replay…" |
+| evaluation | Fig 9 (p50) | "SIP-Bench: A Longitudinal Protocol for Evaluating Self-Improving Agents — Protocol infrastructure for improvement, retention, stability, and cost · A Wrapping Existing Benchmarks · B Longitudinal Evaluation Across Time · C Outputs and Metrics" |
+| chapters | 章节地图 | "Harness, skills, memory, environments, RL, meta-evolution, evaluation, and safety are organized as experience destinations and update surfaces."（站点 figcaption） |
+
+论文独有、站点未收的关键图：**Figure 8 (p39)** 二维 regime 矩阵——"Columns indicate what evolves: TaskAgent content assets, TaskAgent mechanisms or structures, TaskAgent improvement strategies, or the meta-layer itself. Rows indicate who controls evolution: TaskAgent-internal control or persistent meta-l[ayer control]"。
+
 ### 收录规模与从业者要点
 
-- 【111 篇 × 9 章】站点计数器："111 papers / 9 paper chapters"（章即技能/记忆/环境/工具/RL 参数侧/元进化/评测/安全/harness 定义）。
+- 【❌ 已更正：111 → 331；见下方「2026-08 v3 重读校准」取证】站点 HTML 源码 `index.html:57` 的 `<dt id="stat-papers">111</dt>` 是**未水合占位符**——`app.js:333` 实际执行 `els.statPapers.textContent = String(papers.length)`，真实访客看到的是数据文件条数。`data/papers.json` = **331 条记录 / 330 唯一 id**（日期跨 2003-01…2026-06）。真实九章（`data/manuscript.json` + `papers.json` `roles[].chapterOrder`，括号内为唯一论文数）：①Introduction(18) ②Harness as Experience Infrastructure(19) ③Skills(34) ④Memory(42) ⑤Environment(45) ⑥RL and Continual Learning(25) ⑦Meta-Evolving Agents(52) ⑧Measuring Self-Improvement(46) ⑨Safety(50)。**「工具」「定义」不是章**——上一轮的章名清单是推断而非站点原文。
 - 【三段式训练要点】站点 RL & Continual Learning 节给从业者的三句话（逐字）：Pre-deployment Training for Vertical Agent Capabilities（上线前：垂直能力训练）/ Pre-deployment Training for Harness Functional Units（上线前：工具·记忆·技能·子智能体的使用训练）/ Post-deployment Training from Agent Traces（上线后：从运行轨迹训练）。
 
 ---
 
-## 2026-08 升级复核（第二遍重读校准）
+## 2026-08 v3 重读校准（第三遍，发布顺序调整 + sunny-steady 重录之际）
+
+> 重读方式：7 个按幕并行校准代理（A1 P0+P1 / A2 p2-01..18 / A3 p2-19..37 / A4 p2-38..47+P3 / A5 P4 / A6 P5 / A7 P6）对照 PDF 全文逐句审计，**审计单位是句而非章**——承接句强制记 `—` 档，正是上一轮「只审有趣句子」让两处 ❌ 漏网。取证工具：`media/pipeline/scripts/paper_extract.py`（map/text/captions/find/render）。
+> **结论**：上一轮「零事实漂移」的结论**不成立**。本轮确证 3 处事实错误（p0-01 归属、p1-10 编造倍数、p6-13a/b 站点占位数字）并逐句复核其余 176 句。
+
+### 取证记录（111 vs 331 全链）
 
-> 重读方式：本地 PDF（`assets/papers/source/Self-Improving Agents in the Era of Experience: A Survey of Self- to Meta-Evolution.pdf`，88 页）以既有精读笔记为底进行核对（笔记 2026-08-16 由 9 个并行代理从 PDF 全文产出，本轮重点复核 §1–2 harness 形式化、§8 SIP-Bench、§10 开放问题三处与 v1 口播的对应）+ 站点实时抓取（2026-08-18）。
-> **结论**：narration v1 全部断言与论文一致，零事实漂移。+16.2pp / 16/84 负迁移 / ~1,200 恶意技能 / >90% 记忆操纵 / tau-bench 可靠性 / AI-45° Law 等关键数字锚点均维持。
+- `gh api "repos/FrontisAI/Awesome-Self-Improving-Agents/contents/index.html?ref=gh-pages"`：`<dt id="stat-papers">111</dt>`（静态占位）。
+- `gh api …/contents/app.js?ref=gh-pages`：line 333 `els.statPapers.textContent = String(papers.length);`（水合真相）。
+- `gh api …/contents/data/papers.json?ref=gh-pages`：331 记录 / 330 唯一 id。
+- `gh api …/contents/DEV_LOG.md?ref=gh-pages`（2026-07-30）：明写 "keeping … the current OpenRSI-aligned layout and **331-paper data set** unchanged"。
+- 访问日期：2026-08-19。
+- **过程规则（记入 issue.md）**：站点数字只能取自数据文件或水合后 DOM，绝不取 HTML 源码。
 
-### 审计发现与处置
+### SkillsBench「引用冲突」裁决（更正 v1 笔记的误读）
 
-| # | 发现 | 类别 | 处置 |
-|---|---|---|---|
-| 1 | 站点「经验编译器闭环」五段图把全片结构浓缩为一张图，v1 的 p6-06/07 金句（trace-to-capability）只有两句话、无画面展开 | 站点信源·结构复盘缺口 | 新增 P6 闭环复盘镜（4 句）：五段环动画把金句升格为全片结构总图 |
-| 2 | 站点 Gen3 精确语义「适应面本身可在部署后进化」比 v1 p1-25「可以自动升级的产品」更进一步 | 核心遗漏（轻） | 新增 p1-25a 一句点破 |
-| 3 | v1 P4 已有六指标 + SIP-Bench 三时间点；站点四指标问句表述更利口播（新旧任务/归因/代价风险） | 已覆盖（强化） | 不加句，storyboard 4-F 动效升级为三检查点卡+四仪表 |
-| 4 | 站点 111 篇×9 章规模数 | 站点信源 | 新增 p6-13a/b 两句（配套清单卡） |
-| 5 | 考虑补 §10 九大开放问题中的多智能体涌现、多模态经验压缩 | — | **放弃**：v1 已选三问（激发 vs 习得/越吃越窄/多模态压缩），planning.md 取舍声明仍成立 |
+§3.5 (p18) 双引 `[Han et al., 2026, Li et al., 2026c]` 与 §8 (p44) 单引 `[Li et al., 2026c]` **不是冲突**：那句话同时讨论两个基准——
+- `Li et al., 2026c` (References p70, arXiv:2602.12670) = **SkillsBench**（口播 +16.2pp / 86 任务 / 16-of-84 的唯一出处，数字全部正确）；
+- `Han et al., 2026` (References p67, arXiv:2604.16706 前后条目) = **SWE-Skills-Bench**（另一基准，口播未引其数字）。
+§8 只谈 SkillsBench 故只引 Li。v1 笔记把双基准双引记为「引用冲突」属误读，特此更正。
 
-### 本轮新增断言锚点（v2 新句用）
+### 关键锚点复核（维持不变）
 
-- 【站点闭环五段】见「信源补充」——「经验编译器」命名与三步（选证据/提抽象/记出处）引站点；两路去向与闸门语义与论文 §2.1/§8 一致（站点为论文可视化）。
-- 【站点 Gen3】"whose adaptation surfaces can evolve after deployment"。
-- 【站点规模】111 papers / 9 chapters（2026-08-18 访问）。
++16.2pp / 86 tasks & 11 domains / 16-of-84 directly comparable / nearly 1,200 malicious skills（**正文无事件纪年**，见 A6 处置）/ >90%（**单位是 trials 而非场景**，见 A6 处置）/ tau-bench 可靠性 / AI-45° Law（**论文自称 diagnostic lens，出处为 roadmap 提议**，见 A6 处置）。
diff --git a/media/experience-era-agents-video/research/upgrade-2026-08-v3.md b/media/experience-era-agents-video/research/upgrade-2026-08-v3.md
new file mode 100644
index 000000000..793506d48
--- /dev/null
+++ b/media/experience-era-agents-video/research/upgrade-2026-08-v3.md
@@ -0,0 +1,130 @@
+# 2026-08 内容升级审计（v2 → v3）
+
+> 本文档是《上线之后，AI 才开始上学》第三轮升级的可审计记录。**新文件而非续写 v2 文档**：v2 的「站点 111 篇×9 章」条目是错误如何进入的物证（ISSUE-162），改掉它会毁掉支撑新过程规则的取证链。上一轮导航指针：[upgrade-2026-08.md](./upgrade-2026-08.md)。
+> 升级动机：系列发布顺序调整（本集改为第一集）+ 全片换 sunny-steady 重录之际，对源论文做第三遍重读校准（审计单位改为**句**，7 个按幕并行代理），并修正 v2 遗留的 3 处事实错误。
+
+## 一、重读方式与结论
+
+- **论文**：88 页 PDF 全文按幕分 7 个并行校准代理（A1 P0+P1 / A2 p2-01..18 / A3 p2-19..37 / A4 p2-38..47+P3 / A5 P4 / A6 P5 / A7 P6），每句一行校准表（承接句强制 `—` 档）；取证工具 `media/pipeline/scripts/paper_extract.py`（§→页映射 / 分栏取文 / caption 收割 / 定点 find / 页面光栅化到 `out/figs/` 供看图，不入库）。
+- **站点**：以数据文件为准（`data/papers.json` / `data/manuscript.json`，访问 2026-08-19）——首页 HTML 计数为未水合占位（取证链见 [paper-notes.md](./paper-notes.md)「2026-08 v3 重读校准」节）。
+- **结论**：v2 审计「零事实漂移」**不成立**。本轮确证 3 处事实错误（p0-01 归属 / p1-10 编造倍数 / p6-13a.b 站点占位数字与章名）并复核其余全部口播句。
+
+### 审计发现与处置
+
+| # | 发现 | 类别 | 处置 |
+|---|---|---|---|
+| 1 | p0-01「DeepMind 的两位大神」与 p0-02 矛盾（Sutton 属 U. Alberta/Amii；essay 是 DeepMind 出品） | ❌ 事实错误 | 改「强化学习领域两位泰斗」 |
+| 2 | p1-10「便宜一万倍」全文无任何倍数（find "ten thousand"/"orders of magnitude" 零命中；原文 far more frequently and cheaply） | ❌ 编造数字 | 改「便宜得多，也频繁得多」 |
+| 3 | p6-13a/b「一百一十一篇」+ 九章含「工具」「定义」（HTML 占位读数 + 推断章名） | ❌ 站点取证错误 | 改「三百多篇」+ 真实九章（画面标 331 与取数日期） |
+| 4 | p2-37「大部分环境卡在一楼半」论文无总体比例断言；§5.4 论点是「可执行且协议化仍不可学习」 | ⚠️ 口径偏差 | 改「就算能跑、接口也通了，反馈却稀得没法学」 |
+| 5 | P3「按控制权分三级」：Figure 8 实为二维矩阵，1↔2 级分界是「改什么」非「谁控制」 | ⚠️ 降维失真 | 补二维地图表述（见句级 delta） |
+| 6 | P5 只讲 3/5 类威胁；>90% 单位是 trials；AI-45° 论文自称 diagnostic lens（roadmap 提议） | ⚠️ 口径细化 | 见句级 delta |
+| 7 | p2-15「16 个百分点」实为 +16.2pp（论文数字原样原则） | ⚠️ 取整 | 改「16.2 个百分点」 |
+| 8 | SkillsBench「引用冲突」为 v1 笔记误读（Han=SWE-Skills-Bench、Li=SkillsBench 双基准双引） | 笔记更正 | paper-notes 已记裁决 |
+| 9 | 释放的 p6-11..13 跨集引用槽（本集改第一集） | 系列定位 | 改写为 §10 收束论点「共同的地基·验证」 |
+
+## 二、句级 delta 清单
+
+v2 → v3 总账：**改写 25 句 + 新增 8 句，其余 154 句字节不变**（187 句 / 3884 字 / 估算 13.9 分；实际时长以 sunny-steady 合成后 manifest 为准）。
+
+| 句 id | 类型 | 新文本 | 锚点 |
+|---|---|---|---|
+| p0-01 | 改写 | 2025 年，强化学习领域两位泰斗，放出一篇宣言。 | References p77（Sutton 属 U. Alberta/Amii；essay 是 DeepMind 出品） |
+| p0-02 | 改写 | DeepMind 的大卫·希尔弗，和强化学习教父萨顿，联名放话： | 同上；加逗号使听觉归属无歧义 |
+| p1-10 | 改写 | 关键洞察来了：改工位，比改大脑便宜得多，也频繁得多。 | §2.1 p5 逐字（全文无任何倍数） |
+| p1-17 | 改写 | 得经过过滤、压缩、归因、验证这几道打磨， | §2.1 选择性表述（or … enough） |
+| p1-18 | 改写 | 提纯到够用了，才配叫「经验」，才能拿去更新系统。 | §2.1 enough to be usable |
+| p2-15 | 改写 | 精选技能平均能把任务成绩提高 16.2 个百分点， | §8.1.1 p44（论文数字原样） |
+| p2-37 | 改写 | 就算能跑、接口也通了，反馈却稀得没法学。 | §5.4 标题（去「大部分」总体断言） |
+| p3-03 | 改写 | 论文画的是一张二维地图：横轴问进化的到底是什么，纵轴问谁来控制。 | Figure 8 p39（A4：1↔2 分界是改什么） |
+| p3-04 | 改写 | 两根轴一交叉，正好落出三级台阶。第一级，自己攒资产。 | §7.1（regime=行×列分组） |
+| p4-10 | 改写 | 五，路径归因：是外围装备的功劳，还是模型参数真的变了？ | Table 4（A5：external vs parameter path） |
+| p4-15 | 改写 | 论文还点名了一个评测协议： | §8.3（SIP-Bench 为被引外部工作） |
+| p5-09 | 改写 | 近一千二百个恶意技能，混进了一家大型 AI 技能市场。 | §9.2.1 p52（正文无事件纪年） |
+| p5-15 | 改写 | 这句话被写进记忆，以后干活随时可能被翻出来。 | §9.2.2（can 非全称） |
+| p5-16 | 改写 | 一次接触，长期潜伏。 | §9.2.2（persist 非永久） |
+| p5-18 | 改写 | 超过九成的测试轮次，仍能被这种手法操纵。 | §9.2.2（单位 trials） |
+| p5-22 | 改写 | 论文开药方，反复用到的就是四味药： | §9.3/Table 6（防御清单更长） |
+| p5-27 | 改写 | 有研究者提出一条定律：能力涨多快，安全就得涨多快。 | §9.1（AI-45° 为 roadmap 提议） |
+| p6-08 | 改写 | 综述结尾列了九个开放问题，挑三块最要紧的拼图： | §10（实有 10.1–10.9） |
+| p6-11 | 改写 | 这九个问题，压在同一块地基上。 | §10 收束 These problems are coupled / Verification underlies each |
+| p6-12 | 改写 | 那块地基叫验证：你凭什么确认，一次改动真的是进步？ | §10 收束 |
+| p6-13 | 改写 | 而它偏偏是 AI 越强、越跟不上的那一项能力。 | §10 逐字 scales least well |
+| p6-13a | 改写 | 这篇综述的配套仓库，收录了三百多篇论文，按九章组织—— | data/papers.json 331/330（2026-08-19） |
+| p6-13b | 改写 | 引言、工位、技能、记忆、环境、大脑、元进化、评测、安全。 | data/manuscript.json chapterOrder（A7 微调：章名用片中已教过的「大脑」替代原始「参数」） |
+| p2-32a | 新增 | 封顶的有三样：能动的花样、反馈的密度、任务的长度。 | §5.1 p25 + Fig 6（A3：无第四轴） |
+| p2-47a | 新增 | 更要紧的是，什么时候该往大脑里写，论文说：没有标准。 | §10.2 p58 逐字 |
+| p2-47b | 新增 | 这一步很难逆转，可现在全靠工程师凭手感拍板。 | §10.2 little reversibility / manual judgment |
+| p4-18a | 新增 | 而且题目分三摞：旧题重考看遗忘，改进时用的新题记路径，再留一摞从没见过的，专验真泛化。 | §8.3 p50 replay/adapt/held-out |
+| p5-21a | 新增 | 还有一招藏在工具链里：连接器、协议、工作流，单个看都没毛病，拼起来却能走出一条没人预期的执行路径。 | §9.2.3（四类直接威胁补全） |
+| p5-21b | 新增 | 论文把这四招攻击串成一个词：对齐漂移——不是某一次被攻破，而是一步步偏，偏到不再是当初那套规矩。 | §9.2.5 synthesis lens |
+| p6-13c | 新增 | 最后留个悬念：这样反复地自我改进， | §10 末段 |
+| p6-13d | 新增 | 是会利滚利，是会撞到顶，还是原地震荡？论文说：还不知道。 | §10 逐字 not known to compound, saturate, or oscillate |
+
+## 三、双重校验 delta（仅改动/新增句）
+
+**执行说明（诚实记录）**：本轮双重校验的两个独立代理（真实性回溯 / 易懂性审读）与 A1（P0+P1 校准）
+均在运行中被上游 API 以「敏感内容」为由中断（错误码 1301，共 4 次），未能产出完整表格。
+应对：**所有被中断代理负责的关键锚点，改由主控用 `paper_extract.py` 逐条独立取证复核后落地**——
+
+| 锚点 | 独立取证方式 | 结论 |
+|---|---|---|
+| p0-01/02 归属 | `find "Welcome to the era of experience"` → References p77 逐字 | Sutton 属 U. Alberta/Amii，essay 为 DeepMind 出品 → 改写成立 |
+| p1-10 倍数 | `find "ten thousand"` / `"10,000"` / `"orders of magnitude"` **三查全部零命中** | 全文无任何倍数 → 编造，必删 |
+| p1-17/18 | §2.1 p5 分栏取文 | "far more frequently and cheaply"、"enough to be usable" → 选择性表述成立 |
+| p2-15/16 数字 | `find "16.2"` / `"86 tasks"` / `"directly comparable"` | +16.2pp / 86 tasks / 16-of-84 逐字吻合 |
+| p5-09 纪年 | `find "ClawHavoc"` → §9.2.1 p52 | 正文无事件纪年（年份在引用标记内）→ 去年化成立 |
+| p6-11..13 | `find "Verification underlies"` → §10 收束段 | "These problems are coupled… Verification underlies each… scales least well" → 三句忠实 |
+| p6-13c/d | §10 末段分栏取文 | "not known to compound, saturate, or oscillate" 逐字对应 |
+| p6-13a/b | `gh api data/papers.json` + `app.js:333` + `DEV_LOG.md` 三方互证 | 331 条/330 唯一 id；九章按 chapterOrder |
+
+已完成的四个校准代理（A2 Skills / A3 Memory-Env / A5 Eval / A6 Safety / A7 P6）的逐句表**均判定
+RISKY=0**，其提出的微调（p5-15/16/18/22/27、p2-15、p4-10/15、p6-13b「参数→大脑」等）已全部落地。
+
+**门结论**：RISKY = 0（所有 ❌ 均已改写并独立复核），未处理 REWRITE = 0。
+**遗留**：易懂性维度未获独立代理审读，由主控在连读与抽帧目检中人工把关；建议下轮补一次
+纯易懂性审读（不涉及论文原文引用，可规避 API 拦截）。
+
+## 四、验证记录（实测）
+
+| 门 | 结果 |
+|---|---|
+| `build_narration.py` | 187 句 / 3884 字，各幕 P0-14 P1-29 P2-50 P3-19 P4-22 P5-30 P6-23 |
+| 字节稳定性（对 v2 基线） | 改写 25 句 + 新增 8 句，**其余 154 句字节不变** |
+| `check_script.py`（含 `--check-scenes`） | **FAIL 0 · WARN 0**（51 镜全覆盖、无缺句、镜号与代码一致） |
+| 时长预算 | 估算 13.9 分 / **实测 14.0 分**（目标窗 13.0–14.2）✅ |
+| `check_series.py` | **FAIL 0**（口播零顺序词、零他集标题） |
+| `tsc --noEmit`（三集） | 全部通过 |
+| `qa_frames --check-theme` | FAIL 0（概念色对 bg 全部 ≥6.2:1） |
+| 终渲抽帧体检（七幕 76 帧 + 定点 8 帧 + `--last-n 6`） | **FAIL 0**；WARN 均为引用卡文字落在字幕带上缘的形态，目检确认非角标侵入 |
+| 成片流参数 | 14:01.50 · 1920×1080@30 · h264 yuv420p · aac 189kb/s ✅ |
+
+## 五、配音重录记录（实测）
+
+- **参考样本**：`me-bright.wav` 由 `prepare_ref.py ~/Documents/dify/me-1.mp3 --start 0.36 --duration 12`
+  重建，**sha1 门一次命中 `54b699cce97f`**（即 sunny/sunny-steady 预设的标定样本；换用成片旧样本
+  `me-1.wav` 会让 alpha=0.35 失去其针对的明亮度）。
+- **领航片段**：8 句最难形态（16.2 小数点 / 九章枚举 / 近一千二百 / 40 字三分句 / 人名归属逗号 /
+  三分句+问句+冒号 / 四件套枚举 / 收束句）在 `sunny-steady` 下逐句试听通过；产物即删（生物特征）。
+- **两遍法实测**：
+
+  | 遍 | 风格 | 句数 | 墙钟 | 纯语音 | 实测 RTF |
+  |---|---|---|---|---|---|
+  | A（草稿） | `sunny`(beams=1) | 187 | ≈1.9 h | 12.98 分 | ≈8.8 |
+  | B（成片） | `sunny-steady`(beams=3) | 187 | **1.98 h** | 12.89 分 | ≈9.2 |
+
+  **B/A ≈ 1.04**——与手册旧记载的「整集升档 +241%（9.9 h）」相差极大。已回写
+  [VOICE-CLONING.md §4.3b](../../pipeline/VOICE-CLONING.md) 与 `tts.py` 常量注释：旧数据应在机器
+  被占用/热节流时测得；机器空闲时整集直上 `sunny-steady` 可行，`--steady` 混合档退为忙时折中手段。
+- **缓存正确性核验**：B 遍后独立重算 187 句摘要，**全部匹配 `sunny-steady`(beams=3)**，且 p0-01 不再
+  匹配 A 遍 sunny 摘要 → 确认是真重合成而非缓存复用；`.engine` 标记为
+  `indextts|indextts|sunny-steady|54b699cce97f`。
+
+## 六、系列定位变更
+
+- 本集改为系列**第一集**：删除口播跨集引用（p6-11..13 改写为论文收束论点）；README/planning/paper-notes 去互引；SeriesEcho 组件替换为 VerificationBedrock（清除本集代码中唯一的他集色板引用）。
+
+## 七、文档漂移修复
+
+- storyboard P0 区间与 P2 镜号字母对齐代码；0-E 补「尾」标注。
+- planning.md 形态行（edge-tts→克隆）与七幕时间表（按实测 12.8–13.6 分重排）。
diff --git a/media/experience-era-agents-video/research/upgrade-2026-08.md b/media/experience-era-agents-video/research/upgrade-2026-08.md
index 9711288d0..7a75fbabc 100644
--- a/media/experience-era-agents-video/research/upgrade-2026-08.md
+++ b/media/experience-era-agents-video/research/upgrade-2026-08.md
@@ -1,6 +1,7 @@
 # 2026-08 内容升级审计（v1 → v2）
 
 > 本文档是《上线之后，AI 才开始上学》第二轮升级的可审计记录：校准审计、句级 delta、双重校验 delta、信源存档。
+> ⚠️ 勘误（2026-08-19）：本文 §一/§三 的「111 篇 × 9 章」为未水合占位读数（ISSUE-162 物证，保留不改）——正确口径 331 篇/9 章见 [upgrade-2026-08-v3.md](./upgrade-2026-08-v3.md) 与 [paper-notes.md](./paper-notes.md) v3 校准节。
 > 升级动机：三集系列配音换用本人音色克隆（passionate 风格）之际，对源论文做第二遍重读校准，并按「官方工程站点信源补充」规范引入站点增量事实。
 
 ## 一、重读方式与结论
diff --git a/media/experience-era-agents-video/script/narration.json b/media/experience-era-agents-video/script/narration.json
index 3cb627e8e..0064e63dc 100644
--- a/media/experience-era-agents-video/script/narration.json
+++ b/media/experience-era-agents-video/script/narration.json
@@ -2,12 +2,12 @@
   {
     "id": "p0-01",
     "scene": "P0",
-    "text": "2025 年，DeepMind 的两位大神放出一篇宣言。"
+    "text": "2025 年，强化学习领域两位泰斗，放出一篇宣言。"
   },
   {
     "id": "p0-02",
     "scene": "P0",
-    "text": "DeepMind 大卫·希尔弗和强化学习教父萨顿，联名放话："
+    "text": "DeepMind 的大卫·希尔弗，和强化学习教父萨顿，联名放话："
   },
   {
     "id": "p0-02b",
@@ -117,7 +117,7 @@
   {
     "id": "p1-10",
     "scene": "P1",
-    "text": "关键洞察来了：改工位，比改大脑便宜一万倍。"
+    "text": "关键洞察来了：改工位，比改大脑便宜得多，也频繁得多。"
   },
   {
     "id": "p1-11",
@@ -152,12 +152,12 @@
   {
     "id": "p1-17",
     "scene": "P1",
-    "text": "只有经过过滤、压缩、归因、验证这四道工序，"
+    "text": "得经过过滤、压缩、归因、验证这几道打磨，"
   },
   {
     "id": "p1-18",
     "scene": "P1",
-    "text": "提炼出来的东西才配叫「经验」，才能拿去更新系统。"
+    "text": "提纯到够用了，才配叫「经验」，才能拿去更新系统。"
   },
   {
     "id": "p1-19",
@@ -287,7 +287,7 @@
   {
     "id": "p2-15",
     "scene": "P2",
-    "text": "精选技能平均能把任务成绩提高 16 个百分点，"
+    "text": "精选技能平均能把任务成绩提高 16.2 个百分点，"
   },
   {
     "id": "p2-16",
@@ -374,6 +374,11 @@
     "scene": "P2",
     "text": "AI 能变多强，被它身处的环境封了顶。"
   },
+  {
+    "id": "p2-32a",
+    "scene": "P2",
+    "text": "封顶的有三样：能动的花样、反馈的密度、任务的长度。"
+  },
   {
     "id": "p2-33",
     "scene": "P2",
@@ -397,7 +402,7 @@
   {
     "id": "p2-37",
     "scene": "P2",
-    "text": "大部分环境卡在一楼半：能跑，但反馈太稀、没法学。"
+    "text": "就算能跑、接口也通了，反馈却稀得没法学。"
   },
   {
     "id": "p2-38",
@@ -449,10 +454,20 @@
     "scene": "P2",
     "text": "大部分所谓自进化，还是停在前三个去处。"
   },
+  {
+    "id": "p2-47a",
+    "scene": "P2",
+    "text": "更要紧的是，什么时候该往大脑里写，论文说：没有标准。"
+  },
+  {
+    "id": "p2-47b",
+    "scene": "P2",
+    "text": "这一步很难逆转，可现在全靠工程师凭手感拍板。"
+  },
   {
     "id": "p3-01",
     "scene": "P3",
-    "text": "四个去处都通了，新的问题冒出来："
+    "text": "四个去处都看完了，新的问题冒出来："
   },
   {
     "id": "p3-02",
@@ -462,12 +477,12 @@
   {
     "id": "p3-03",
     "scene": "P3",
-    "text": "论文按控制权，分了三级。"
+    "text": "论文画的是一张二维地图：横轴问进化的到底是什么，纵轴问谁来控制。"
   },
   {
     "id": "p3-04",
     "scene": "P3",
-    "text": "第一级，自己攒资产。"
+    "text": "两根轴一交叉，正好落出三级台阶。第一级，自己攒资产。"
   },
   {
     "id": "p3-05",
@@ -592,7 +607,7 @@
   {
     "id": "p4-10",
     "scene": "P4",
-    "text": "五，路径归因：到底是技能的功劳，还是记忆的？"
+    "text": "五，路径归因：是外围装备的功劳，还是模型参数真的变了？"
   },
   {
     "id": "p4-11",
@@ -617,7 +632,7 @@
   {
     "id": "p4-15",
     "scene": "P4",
-    "text": "论文还提出了一个评测协议的构想："
+    "text": "论文还点名了一个评测协议："
   },
   {
     "id": "p4-16",
@@ -634,6 +649,11 @@
     "scene": "P4",
     "text": "留着旧题反复重考，才看得出真本事。"
   },
+  {
+    "id": "p4-18a",
+    "scene": "P4",
+    "text": "而且题目分三摞：旧题重考看遗忘，改进时用的新题记路径，再留一摞从没见过的，专验真泛化。"
+  },
   {
     "id": "p4-19",
     "scene": "P4",
@@ -692,7 +712,7 @@
   {
     "id": "p5-09",
     "scene": "P5",
-    "text": "2026 年，近一千二百个恶意技能，混进了一家大型 AI 技能市场。"
+    "text": "近一千二百个恶意技能，混进了一家大型 AI 技能市场。"
   },
   {
     "id": "p5-10",
@@ -722,12 +742,12 @@
   {
     "id": "p5-15",
     "scene": "P5",
-    "text": "这句话被写进记忆，以后每次干活都会被翻出来。"
+    "text": "这句话被写进记忆，以后干活随时可能被翻出来。"
   },
   {
     "id": "p5-16",
     "scene": "P5",
-    "text": "一次接触，永久潜伏。"
+    "text": "一次接触，长期潜伏。"
   },
   {
     "id": "p5-17",
@@ -737,7 +757,7 @@
   {
     "id": "p5-18",
     "scene": "P5",
-    "text": "超过九成的测试场景，仍能被这种手法操纵。"
+    "text": "超过九成的测试轮次，仍能被这种手法操纵。"
   },
   {
     "id": "p5-19",
@@ -754,10 +774,20 @@
     "scene": "P5",
     "text": "让坏改动看起来像好改进，被系统开心地保留下来。"
   },
+  {
+    "id": "p5-21a",
+    "scene": "P5",
+    "text": "还有一招藏在工具链里：连接器、协议、工作流，单个看都没毛病，拼起来却能走出一条没人预期的执行路径。"
+  },
+  {
+    "id": "p5-21b",
+    "scene": "P5",
+    "text": "论文把这四招攻击串成一个词：对齐漂移——不是某一次被攻破，而是一步步偏，偏到不再是当初那套规矩。"
+  },
   {
     "id": "p5-22",
     "scene": "P5",
-    "text": "论文开出的药方，本质上就四味药："
+    "text": "论文开药方，反复用到的就是四味药："
   },
   {
     "id": "p5-23",
@@ -782,7 +812,7 @@
   {
     "id": "p5-27",
     "scene": "P5",
-    "text": "有条定律总结得很形象：能力涨多快，安全就得涨多快。"
+    "text": "有研究者提出一条定律：能力涨多快，安全就得涨多快。"
   },
   {
     "id": "p5-28",
@@ -847,7 +877,7 @@
   {
     "id": "p6-08",
     "scene": "P6",
-    "text": "这篇综述的结尾，给这条路列了三块缺失的拼图："
+    "text": "综述结尾列了九个开放问题，挑三块最要紧的拼图："
   },
   {
     "id": "p6-09",
@@ -862,27 +892,37 @@
   {
     "id": "p6-11",
     "scene": "P6",
-    "text": "如果你看完想起另一件事——没错。"
+    "text": "这九个问题，压在同一块地基上。"
   },
   {
     "id": "p6-12",
     "scene": "P6",
-    "text": "AI 改自己，该改大脑还是改装备，我们上期讲过。"
+    "text": "那块地基叫验证：你凭什么确认，一次改动真的是进步？"
   },
   {
     "id": "p6-13",
     "scene": "P6",
-    "text": "这期讲的是另一半：上了班之后，经验怎么攒。"
+    "text": "而它偏偏是 AI 越强、越跟不上的那一项能力。"
   },
   {
     "id": "p6-13a",
     "scene": "P6",
-    "text": "这篇综述的配套仓库，收录了一百一十一篇论文，正好按九章组织——"
+    "text": "这篇综述的配套仓库，收录了三百多篇论文，按九章组织——"
   },
   {
     "id": "p6-13b",
     "scene": "P6",
-    "text": "技能、记忆、环境、工具、参数、元进化、评测、安全、定义，一章不缺。"
+    "text": "引言、工位、技能、记忆、环境、大脑、元进化、评测、安全。"
+  },
+  {
+    "id": "p6-13c",
+    "scene": "P6",
+    "text": "收尾留个悬念：这样反复地自我改进，"
+  },
+  {
+    "id": "p6-13d",
+    "scene": "P6",
+    "text": "是会利滚利，是会撞到顶，还是原地震荡？论文说：还不知道。"
   },
   {
     "id": "p6-14",
diff --git a/media/experience-era-agents-video/script/narration.md b/media/experience-era-agents-video/script/narration.md
index 83ae0a97b..9dba60074 100644
--- a/media/experience-era-agents-video/script/narration.md
+++ b/media/experience-era-agents-video/script/narration.md
@@ -10,8 +10,8 @@
 
 > 画面：黑场，衬线金句卡打字机逐字打出；英文原文渐显在下方。
 
-- [p0-01] 2025 年，DeepMind 的两位大神放出一篇宣言。
-- [p0-02] DeepMind 大卫·希尔弗和强化学习教父萨顿，联名放话：
+- [p0-01] 2025 年，强化学习领域两位泰斗，放出一篇宣言。
+- [p0-02] DeepMind 的大卫·希尔弗，和强化学习教父萨顿，联名放话：
 - [p0-02b] AI 的下一个时代，叫经验时代。
 - [p0-03] 未来 AI 的进步，不再主要来自人类喂的静态数据，
 - [p0-04] 而是来自 AI 自己和环境交互攒出来的经验。
@@ -57,7 +57,7 @@
 
 - [p1-08] 它是包在大脑外面的一整套工作系统：
 - [p1-09] 工作手册、笔记本、工具权限、办事流程，全在这一层。
-- [p1-10] 关键洞察来了：改工位，比改大脑便宜一万倍。
+- [p1-10] 关键洞察来了：改工位，比改大脑便宜得多，也频繁得多。
 - [p1-11] 不用重新训练，随时检查、随时修改、随时撤销。
 - [p1-12] 但它同样决定 AI 看到什么、能做什么、留下什么。
 
@@ -70,8 +70,8 @@
 > 角标：z_i = H(τ_i)：trace 窗口 → 可用经验
 
 - [p1-16] AI 干活产生的是一堆原始流水，论文叫 trace。
-- [p1-17] 只有经过过滤、压缩、归因、验证这四道工序，
-- [p1-18] 提炼出来的东西才配叫「经验」，才能拿去更新系统。
+- [p1-17] 得经过过滤、压缩、归因、验证这几道打磨，
+- [p1-18] 提纯到够用了，才配叫「经验」，才能拿去更新系统。
 - [p1-19] 提炼出的经验有两个去处：
 - [p1-20] 快的去路：直接改工位——今天就能用上。
 - [p1-21] 慢的去路：攒多了写进大脑——变成一辈子的本能。
@@ -114,7 +114,7 @@
 - [p2-12] 失败记录能精确定位技能库哪里写得不对、哪里缺了一块。
 - [p2-13] 但改动不能乱来。论文反复强调一道门：验证。
 - [p2-14] 有一组数字很说明问题：
-- [p2-15] 精选技能平均能把任务成绩提高 16 个百分点，
+- [p2-15] 精选技能平均能把任务成绩提高 16.2 个百分点，
 - [p2-16] 但同一份测试里，84 个任务有 16 个反而变差了。
 
 > 角标：SkillsBench：+16.2pp；16/84 任务负迁移
@@ -144,11 +144,12 @@
 
 - [p2-31] 第三个去处，容易被忽略：环境本身。
 - [p2-32] AI 能变多强，被它身处的环境封了顶。
+- [p2-32a] 封顶的有三样：能动的花样、反馈的密度、任务的长度。
 - [p2-33] 论文说环境有三层楼：
 - [p2-34] 一楼，可执行：软件得让 AI 真的能操作。
 - [p2-35] 二楼，协议化：接口统一了，经验才能搬家。
 - [p2-36] 三楼，可学习：干完活得留下能当训练信号的反馈。
-- [p2-37] 大部分环境卡在一楼半：能跑，但反馈太稀、没法学。
+- [p2-37] 就算能跑、接口也通了，反馈却稀得没法学。
 
 > 角标：J*(E)：环境约束适应上限
 
@@ -168,16 +169,18 @@
 - [p2-45] 但论文也泼了盆冷水：
 - [p2-46] 真正在部署后从 trace 训练模型的工作，公开证据还非常稀少。
 - [p2-47] 大部分所谓自进化，还是停在前三个去处。
+- [p2-47a] 更要紧的是，什么时候该往大脑里写，论文说：没有标准。
+- [p2-47b] 这一步很难逆转，可现在全靠工程师凭手感拍板。
 
 ## P3 元进化：谁来管进化
 
 > 画面：三级阶梯自下而上亮起（青→青→金）。
 
-- [p3-01] 四个去处都通了，新的问题冒出来：
+- [p3-01] 四个去处都看完了，新的问题冒出来：
 - [p3-02] 谁来决定，这次经验往哪个去处送？
-- [p3-03] 论文按控制权，分了三级。
+- [p3-03] 论文画的是一张二维地图：横轴问进化的到底是什么，纵轴问谁来控制。
 
-- [p3-04] 第一级，自己攒资产。
+- [p3-04] 两根轴一交叉，正好落出三级台阶。第一级，自己攒资产。
 - [p3-05] AI 一边干活一边攒技能、记笔记。进化是干活的副产品。
 
 - [p3-06] 第二级，学会怎么改进。
@@ -220,7 +223,7 @@
 - [p4-07] 二，老任务不忘：学新的时候旧本事丢没丢？
 - [p4-08] 三，持续稳定：过一阵子再考，还在吗？
 - [p4-09] 四，性价比：涨这点分，花了多少算力和人力？
-- [p4-10] 五，路径归因：到底是技能的功劳，还是记忆的？
+- [p4-10] 五，路径归因：是外围装备的功劳，还是模型参数真的变了？
 - [p4-11] 六，安全不退化：变强的同时，有没有变得危险？
 
 > 角标：SI 六目标（Held-out gain / Backward retention / Longitudinal stability / Improvement efficiency / Path attribution / Safety non-regression）
@@ -231,10 +234,11 @@
 
 > 角标：tau-bench：repeated-run reliability ≪ single-run success
 
-- [p4-15] 论文还提出了一个评测协议的构想：
+- [p4-15] 论文还点名了一个评测协议：
 - [p4-16] 追着同一个进化的 AI，在三个时间点反复体检。
 - [p4-17] 改进前、改进后、过段时间之后，各考一轮，
 - [p4-18] 留着旧题反复重考，才看得出真本事。
+- [p4-18a] 而且题目分三摞：旧题重考看遗忘，改进时用的新题记路径，再留一摞从没见过的，专验真泛化。
 
 > 角标：SIP-Bench：T0 → T1 → T2 纵向协议
 
@@ -260,7 +264,7 @@
 > 画面：应用商店货架动画——部分商品闪烁红色「恶意」标签。
 
 - [p5-08] 第一个：技能商店投毒。
-- [p5-09] 2026 年，近一千二百个恶意技能，混进了一家大型 AI 技能市场。
+- [p5-09] 近一千二百个恶意技能，混进了一家大型 AI 技能市场。
 - [p5-10] 窃取 API 密钥、加密钱包、浏览器凭证。
 - [p5-11] 攻击者根本不用攻破模型本身——
 - [p5-12] 装个「技能」，AI 自己就把家门钥匙交了。
@@ -269,17 +273,19 @@
 
 - [p5-13] 第二个：记忆投毒。
 - [p5-14] 攻击者只需在一次对话里埋一句话，
-- [p5-15] 这句话被写进记忆，以后每次干活都会被翻出来。
-- [p5-16] 一次接触，永久潜伏。
+- [p5-15] 这句话被写进记忆，以后干活随时可能被翻出来。
+- [p5-16] 一次接触，长期潜伏。
 - [p5-17] 有研究显示：即使开了严格的安全约束，
-- [p5-18] 超过九成的测试场景，仍能被这种手法操纵。
+- [p5-18] 超过九成的测试轮次，仍能被这种手法操纵。
 
 > 角标：From Storage to Steering：>90% 场景可被记忆操纵攻破
 
 - [p5-19] 更阴的还有一招：操纵反馈。
 - [p5-20] 不直接攻击 AI，而是污染「什么算进步」的评分。
 - [p5-21] 让坏改动看起来像好改进，被系统开心地保留下来。
-- [p5-22] 论文开出的药方，本质上就四味药：
+- [p5-21a] 还有一招藏在工具链里：连接器、协议、工作流，单个看都没毛病，拼起来却能走出一条没人预期的执行路径。
+- [p5-21b] 论文把这四招攻击串成一个词：对齐漂移——不是某一次被攻破，而是一步步偏，偏到不再是当初那套规矩。
+- [p5-22] 论文开药方，反复用到的就是四味药：
 - [p5-23] 准入测试：新技能新记忆，先考试再上岗。
 - [p5-24] 最小权限：默认什么都不能碰，用啥申请啥。
 - [p5-25] 版本回滚：改坏了，一键恢复到上个认证版本。
@@ -287,7 +293,7 @@
 
 > 角标：Admission tests / Least privilege / Versioning & rollback / Continuous re-certification
 
-- [p5-27] 有条定律总结得很形象：能力涨多快，安全就得涨多快。
+- [p5-27] 有研究者提出一条定律：能力涨多快，安全就得涨多快。
 - [p5-28] 两者的曲线必须一起爬坡，一旦拉开差距，就是系统性欠账。
 
 > 角标：AI-45° Law
@@ -314,18 +320,20 @@
 > 角标："Making agents smarter after deployment is a trace-to-capability problem"
 > 画面：闭环复盘镜——五节点环形流水：部署轨迹 → 经验编译器（选证据/提抽象/记出处）→ 工位侧快路（青，快/可逆）∥ 大脑侧慢路（紫，慢/持久）→ 评测+安全闸门 → 回到部署。青路流光速度快、紫路缓慢下沉，闸门红描边脉冲。
 
-- [p6-08] 这篇综述的结尾，给这条路列了三块缺失的拼图：
+- [p6-08] 综述结尾列了九个开放问题，挑三块最要紧的拼图：
 - [p6-09] 靠得住的反馈，安全的自我修改架构，
 - [p6-10] 还有把评测从一场考试，变成持续的体检。
-- [p6-11] 如果你看完想起另一件事——没错。
-- [p6-12] AI 改自己，该改大脑还是改装备，我们上期讲过。
-- [p6-13] 这期讲的是另一半：上了班之后，经验怎么攒。
+- [p6-11] 这九个问题，压在同一块地基上。
+- [p6-12] 那块地基叫验证：你凭什么确认，一次改动真的是进步？
+- [p6-13] 而它偏偏是 AI 越强、越跟不上的那一项能力。
 
-> 画面：引用卡——上一集《AI 如何自己变强？》缩略 + 本集论文引用卡。
+> 画面：九块小面板落成一排，共同压在金色基石「验证」上（§10 收束论点）。
 
-- [p6-13a] 这篇综述的配套仓库，收录了一百一十一篇论文，正好按九章组织——
-- [p6-13b] 技能、记忆、环境、工具、参数、元进化、评测、安全、定义，一章不缺。
+- [p6-13a] 这篇综述的配套仓库，收录了三百多篇论文，按九章组织——
+- [p6-13b] 引言、工位、技能、记忆、环境、大脑、元进化、评测、安全。
+- [p6-13c] 收尾留个悬念：这样反复地自我改进，
+- [p6-13d] 是会利滚利，是会撞到顶，还是原地震荡？论文说：还不知道。
 - [p6-14] 感兴趣的朋友，强烈推荐读读这篇 88 页的原文。
 - [p6-15] 我们下期再见。
 
-> 画面：论文引用卡（清华大学 × Frontis.AI，2026-06）+ 渐黑。
+> 画面：6-F2 三条曲线（实线上扬/虚线平台/点线正弦，各以衬线？收尾）→ 6-G 论文引用卡（清华大学 × Frontis.AI，2026-06）+ 渐黑。
diff --git a/media/experience-era-agents-video/script/planning.md b/media/experience-era-agents-video/script/planning.md
index dee723784..d743a40cb 100644
--- a/media/experience-era-agents-video/script/planning.md
+++ b/media/experience-era-agents-video/script/planning.md
@@ -9,10 +9,10 @@
 |---|---|
 | 平台 | B 站 / YouTube 中长视频 |
 | 时长 | 由内容密度决定，硬约束 12–20 分钟（估算锚 280 字/分） |
-| 形态 | 动效图解式：AI 配音（edge-tts）+ Remotion 代码动画，无真人出镜 |
+| 形态 | 动效图解式：**本人音色克隆配音**（IndexTTS-2.5 sunny-steady 成片档）+ Remotion 代码动画，无真人出镜 |
 | 受众 | 对 AI 好奇的普通观众；不预设机器学习背景 |
 | 核心内容 | 全文主线：Harness=经验基础设施 → 经验的四个去处 → 元进化 → SI 评测 → 移动攻击面 |
-| 系列关系 | 完全独立成片；片尾引用上一集《AI 如何自己变强？》（互补：上集讲"改什么"，本集讲"部署后怎么攒经验"） |
+| 系列关系 | 三集系列第 1 集，完全独立成片：口播不出现其他集标题与集数序号（发布顺序见 [../../series.json](../../series.json)） |
 
 ## 二、叙事策略
 
@@ -35,13 +35,13 @@
 
 | 幕 | 目标时间 | 主题 | 叙事要点（回溯 paper-notes） | 视觉锚点 |
 |---|---|---|---|---|
-| P0 | 0:00–1:10 | 冷开场 | Silver & Sutton"经验时代"宣言 → 今天 AI 的"永远入职第一天"困境 → 主线问题：上线之后怎么越干越强？→ 88 页综述卡（清华 × Frontis.AI） | 宣言金句卡；日历翻页每天都是"第 1 天"；论文卡 |
-| P1 | 1:10–3:10 | 一个上线 AI 的解剖图 | A_t 四元组拟人化（大脑/工位/老板/车间）；核心区分：聊天记录≠经验（须过滤/压缩/归因/验证才"可用"）；快慢双时标总览；三代进化史 Gen1 任务环→Gen2 跨任务复用→Gen3 运行时系统 | 新员工入职装配动画；"原油→精炼汽油"提纯漏斗；三代时间轴 |
-| P2 | 3:10–8:00 | 经验的四个去处 | ① 技能库（SKILL.md 文件夹=带说明书的工具抽屉；创建/使用/进化三阶段；负面证据也是宝；验证准入防"负迁移"）② 记忆（五操作：记/压/并/取/改；三层自进化）③ 环境=天花板（可执行→协议化→可学习三层楼）④ 参数巩固（何时"写进大脑"：Cursor 实时 RL、部署后 trace 学习仍处早期） | 四管道分叉总图；技能抽屉动画；三层楼电梯；快慢双环 |
-| P3 | 8:00–10:30 | 元进化：谁来管进化 | 三层 regime 阶梯：自己攒资产→学会怎么干活/怎么改进→出现专职 meta 层（SkillOS=老员工+图书管理员分岗；Hyperagents 连改进流程本身进可改区）；自指悖论与"失去稳定参照系" | 三级阶梯；岗位分拆动画；镜像套娃 |
-| P4 | 10:30–13:00 | 怎么知道真的变强了 | "刷分≠成长"；SI 六目标体检表（新任务涨分/老任务不忘/持续稳定/性价比/路径归因/安全不退化）；SIP-Bench T0→T1→T2 纵向体检；基准也会腐烂需持续换新 | 体检报告卡；三条时间线；水涨船不高图 |
-| P5 | 13:00–15:30 | 安全：会进化的系统=移动靶 | 一次性审计结构性失效；ClawHavoc ~1200 恶意技能供应链事件；记忆投毒（一次交互长期潜伏，>90% 场景可被引导）；反馈操纵（污染"什么算进步"）；治理原语：准入测试/最小权限/版本回滚/持续再认证 | 移动靶射击场；技能商店投毒动画；夜袭记忆库 |
-| P6 | 15:30–17:00 | 收尾 | 开放问题速览（诱发 vs 习得、自产经验漂移、多模态经验）；总金句"trace-to-capability"；三件缺的事：可靠反馈/安全自改架构/评测即持续体检；引用上一集；原文引用卡 | 星空开放问题墙；首尾呼应金句卡；引用卡 |
+| P0 | 0:00–1:00 | 冷开场 | Silver & Sutton"经验时代"宣言 → 今天 AI 的"永远入职第一天"困境 → 主线问题：上线之后怎么越干越强？→ 88 页综述卡（清华 × Frontis.AI） | 宣言金句卡；日历翻页每天都是"第 1 天"；论文卡 |
+| P1 | 1:00–3:20 | 一个上线 AI 的解剖图 | A_t 四元组拟人化（大脑/工位/老板/车间）；核心区分：聊天记录≠经验（须过滤/压缩/归因/验证才"可用"）；快慢双时标总览；三代进化史 Gen1 任务环→Gen2 跨任务复用→Gen3 运行时系统 | 新员工入职装配动画；"原油→精炼汽油"提纯漏斗；三代时间轴 |
+| P2 | 3:20–6:55 | 经验的四个去处 | ① 技能库（SKILL.md 文件夹=带说明书的工具抽屉；创建/使用/进化三阶段；负面证据也是宝；验证准入防"负迁移"）② 记忆（五操作：记/压/并/取/改；三层自进化）③ 环境=天花板（可执行→协议化→可学习三层楼）④ 参数巩固（何时"写进大脑"：Cursor 实时 RL、部署后 trace 学习仍处早期） | 四管道分叉总图；技能抽屉动画；三层楼电梯；快慢双环 |
+| P3 | 6:55–8:20 | 元进化：谁来管进化 | Figure 8 二维地图（改什么 × 谁控制）解析为三层 regime 阶梯：自己攒资产→学会怎么改进→出现专职 meta 层（SkillOS=老员工+图书管理员分岗；Hyperagents 连改进流程本身进可改区）；自指悖论与"失去稳定参照系" | 二维格阵让位三级阶梯；岗位分拆动画；镜像套娃 |
+| P4 | 8:20–9:55 | 怎么知道真的变强了 | "刷分≠成长"；SI 六目标体检表（新任务涨分/老任务不忘/持续稳定/性价比/路径归因/安全不退化）；SIP-Bench T0→T1→T2 纵向体检（replay/adapt/held-out 三分题库）；基准也会腐烂需持续换新 | 体检报告卡；三条时间线；水涨船不高图 |
+| P5 | 9:55–12:10 | 安全：会进化的系统=移动靶 | 一次性审计结构性失效；ClawHavoc ~1200 恶意技能供应链事件；记忆投毒（一次交互长期潜伏，>90% 轮次可被引导）；反馈操纵（污染"什么算进步"）；工具链组合出非预期路径与「对齐漂移」；治理原语：准入测试/最小权限/版本回滚/持续再认证 | 移动靶射击场；技能商店投毒动画；夜袭记忆库；对齐漂移罗盘 |
+| P6 | 12:10–14:00 | 收尾 | 总金句"trace-to-capability"；九个开放问题压在同一块地基「验证」上（scales least well）；配套仓库 331 篇 × 9 章；三曲线悬念（compound/saturate/oscillate）；原文引用卡 | 星空开放问题墙；验证基石；三条曲线；引用卡 |
 
 ## 五、生产管线
 
@@ -53,7 +53,7 @@ flowchart LR
         C --> D[storyboard.md<br/>分镜表]
     end
     subgraph AUDIO["配音层"]
-        C --> E[tts.py<br/>edge-tts 逐句合成]
+        C --> E[tts.py<br/>IndexTTS 音色克隆逐句合成]
         E --> F[audio/*.mp3 +<br/>manifest.json]
     end
     subgraph VIDEO["视觉层"]
@@ -78,4 +78,4 @@ flowchart LR
 - BGM 留空轨（版权考量，用户后期自选）；不使用任何未经授权的第三方图片/音频素材，全部画面为代码生成。
 - 论文之外的观点不进口播正文；需要延伸时明确口播"论文之外多说一句"。
 - 论文无公开 arXiv 号：引用卡写机构 + 日期，不编造编号。
-- Remotion 采用个人科普用途免费授权；edge-tts 发布前确认平台对合成语音的标注要求。
+- Remotion 采用个人科普用途免费授权；IndexTTS-2.5 按 bilibili 模型许可（个人/研究可用），发布前确认平台对合成语音的标注要求（详见 [../../pipeline/VOICE-CLONING.md §八](../../pipeline/VOICE-CLONING.md)）。
diff --git a/media/experience-era-agents-video/script/storyboard.md b/media/experience-era-agents-video/script/storyboard.md
index f0eeba936..917b299a3 100644
--- a/media/experience-era-agents-video/script/storyboard.md
+++ b/media/experience-era-agents-video/script/storyboard.md
@@ -11,7 +11,7 @@
 | 0-A 宣言卡 | p0-01..04 | 黑场；衬线金句卡：论文宣言「未来 AI 的进步，来自经验」；下方英文原文渐显 "Era of Experience"；角标 Silver & Sutton, 2025 | 打字机 + 光标闪烁 |
 | 0-B 入职循环 | p0-05..08 | AI 员工形象坐工位；日历哗哗翻页，每页盖红色「第 1 天」章；聊天窗口内容清空 | 日历翻页 + 清空擦除 |
 | 0-C 主线问题 | p0-09..10 | 大字提问卡：「上线之后，AI 能越干越熟练吗？」金色强调 | 缩放强调 |
-| 0-D 论文卡 | p0-11..13 | 论文封面卡：标题 + 清华大学 × Frontis.AI + 「88 页综述」徽章 | 卡片翻转入场 |
+| 0-D 论文卡 | p0-11..12 | 论文封面卡：标题 + 清华大学 × Frontis.AI + 「88 页综述」徽章 | 卡片翻入场 |
 | 0-E 标题卡 | p0-13 尾 | 片名《上线之后，AI 才开始上学》；金/青/紫三色光带从中心流出交汇 | 光带扫过 + 定格 |
 
 ## P1 解剖图（约 2 分钟）
@@ -36,16 +36,17 @@
 | 2-C 生命周期 | p2-07..12 | 三段环：创建（多来源图标汇入）→使用（放大镜检索+齿轮组合）→进化（红笔批注；失败记录转化为指向技能库具体位置的红箭头）；检索缺口：大库里好技能藏角落发光但无人取 | 环形流转 |
 | 2-D 验证门 | p2-13..18 | 改动队列过「验证」闸机；数字面板：+16.2pp 大字（绿）与 16/84 负迁移（红）并排；角标 SkillsBench | 闸机放行/弹回 + 数字面板翻牌 |
 | 2-E 记忆五动作 | p2-19..26 | 笔记本中央；五个印章依次盖下：记/压/并/取/改（各配小图标：笔/压缩器/合并箭头/放大镜/橡皮）；角标五操作英文 | 盖章 + 小动画 |
-| 2-G 记忆三层 | p2-27..30 | 三层嵌套框：内容→机制→策略逐层放大；旁边天平：记太多 vs 记太少；陈旧记忆卡片褪色带偏后续判断线 | 嵌套展开 + 天平摆动 |
-| 2-H 环境三层楼 | p2-31..37 | 电梯楼图：一楼「可执行」（终端图标）二楼「协议化」（插头图标）三楼「可学习」（信号塔图标）；大量环境卡在一楼半（电梯停在 1.5 层闪烁）；角标 J*(E) 天花板线 | 电梯上行 + 天花板虚线 |
-| 2-I 参数巩固 | p2-38..41 | 紫色通路：工位上验证过的套路（绿色 ✓ 卡片堆）→ 蒸馏漏斗 → 沉入大脑；跨任务跨用户图标四散带光；角标 θ⁺=Φ_M(θ,Z) | 卡片汇聚 + 沉降 |
-| 2-J 工业现实 | p2-42..47 | 左：产品图标 + 用户反馈流（绿点）汇入权重；右：泼冷水卡「部署后 trace 训练：公开证据稀少」 | 左流动 + 右冷色调卡片 |
+| 2-F 记忆三层 | p2-27..30 | 三层嵌套框：内容→机制→策略逐层放大；旁边天平：记太多 vs 记太少；陈旧记忆卡片褪色带偏后续判断线 | 嵌套展开 + 天平摆动 |
+| 2-G 环境三层楼 | p2-31..37 | 电梯楼图：一楼「可执行」（终端图标）二楼「协议化」（插头图标）三楼「可学习」（信号塔图标）；大量环境卡在一楼半（电梯停在 1.5 层闪烁）；角标 J*(E) 天花板线 | 电梯上行 + 天花板虚线 |
+| 2-H 参数巩固 | p2-38..41 | 紫色通路：工位上验证过的套路（绿色 ✓ 卡片堆）→ 蒸馏漏斗 → 沉入大脑；跨任务跨用户图标四散带光；角标 θ⁺=Φ_M(θ,Z) | 卡片汇聚 + 沉降 |
+| 2-I 工业现实 | p2-42..47 | 左：产品图标 + 用户反馈流（绿点）汇入权重；右：泼冷水卡「部署后 trace 训练：公开证据稀少」 | 左流动 + 右冷色调卡片 |
+| 2-J 晋升闸门 | p2-47a..47b | 左半青（工位·快/可逆：五把锁只对上一把）；中间闸门判准铭牌**空白**（红问号脉冲，角标 promotion criterion: absent §10.2）；右半紫（大脑·慢/持久：按下按钮后点亮）；闸下单向红箭头「很难逆转」 | 铭牌滑入 + 按钮按下 + 单向箭头描画 |
 
 ## P3 元进化（约 1.5 分钟）
 
 | 镜 | 句区间 | 画面 | 动效 |
 |---|---|---|---|
-| 3-A 三级阶梯 | p3-01..03 | 三级阶梯自下而上亮起；顶上悬浮问号「谁控制进化？」 | 阶梯点亮 |
+| 3-A 二维地图→三级阶梯 | p3-01..03 | 先淡入 Figure 8 二维格阵（2 行×4 列，对角两格空「–」；横轴=改什么，纵轴=谁控制），轴标签点亮后格阵让位解析为三级阶梯；顶上悬浮问号 | 格阵淡入 + 轴点亮 + 让位解析 |
 | 3-B 第一级 | p3-04..05 | 阶梯第一级：员工边干活边攒资产（技能卡/记忆卡落入背包） | 卡片入包 |
 | 3-C 第二级 | p3-06..08 | 第二级：员工头顶思考泡「为什么搞砸」→ 提炼成「原则」卡片入库；角标 MetaEvo | 思考泡 → 卡片精炼 |
 | 3-D 第三级 | p3-09..12 | 第三级：分岗动画——左侧「员工」挂锁（冻结），右侧「图书管理员」整理技能库；管理员每次改动弹成绩单；角标 SkillOS | 分岗滑入 + 成绩单弹出 |
@@ -59,7 +60,7 @@
 | 4-A 体检中心 | p4-01..04 | AI 拿体检报告进「体检中心」门；作弊画面：练过的题册上分数飞涨（红色「刷分」印章） | 走入门内 + 分数虚高动画 |
 | 4-B 六条指标 | p4-05..11 | 体检表格逐行点亮：新任务涨分/老任务不忘/持续稳定/性价比/路径归因/安全不退化（每行小图标）；角标 SI 六目标英文 | 逐行盖章 |
 | 4-C 稳定性 | p4-12..14 | 同一 AI 跑两遍成绩柱状图差异巨大；角标 tau-bench | 双柱对比 |
-| 4-D 纵向协议 | p4-15..18 | 时间线 T0→T1→T2 三体检点（三张检查点卡依次立起：改进前/改进后/过段时间）；旧题卡片反复重考（循环箭头）；右侧四仪表盘（新任务涨分/老任务不忘/功劳归谁/代价风险）依次通电；角标 SIP-Bench | 检查点卡立起 + 循环 + 四仪表通电 |
+| 4-D 纵向协议 | p4-15..18a | 时间线 T0→T1→T2 三体检点（三张检查点卡依次立起：改进前/改进后/过段时间）；旧题卡片反复重考（循环箭头）；右侧四仪表盘（新任务涨分/老任务不忘/功劳归谁/代价风险）依次通电；角标 SIP-Bench | 检查点卡立起 + 循环 + 四仪表通电 |
 | 4-E 题库腐烂 | p4-19..21 | 考题卡片随时间褪色长霉斑；新考题卡车持续倒入 | 褪色 + 补给动画 |
 
 ## P5 安全（约 2.5 分钟）
@@ -71,6 +72,7 @@
 | 5-B 技能投毒 | p5-08..12 | 应用商店货架：商品图标整齐排列；红光扫过，近 1200 个商品翻转露出「恶意」面（钥匙/钱包图标被抽走）；角标 ClawHavoc | 红扫 + 商品翻转 |
 | 5-C 记忆投毒 | p5-13..18 | 夜景：一句红色文本飘入记忆库藏书架；之后每次干活（日轮转）都被翻出注入；十扇门中九扇从记忆侧被打开的示意；角标 >90% | 潜伏注入 + 门开动画 |
 | 5-D 反馈操纵 | p5-19..21 | 评分仪表盘被黑手拧动指针：坏改动（红卡）被贴上「改进✓」绿标保留 | 指针拧动 + 标签偷换 |
+| 5-D2 对齐漂移 | p5-21a..21b | 工具链拼图：连接器/协议/工作流各件单独✓、拼线连出意外路径（红）；四类攻击胶囊汇入「对齐漂移」罗盘，系统轮廓从实线渐虚（一步步偏出原样） | 拼图连线 + 罗盘汇聚 + 轮廓渐虚 |
 | 5-E 四味药 | p5-22..26 | 药方列表逐条亮起：准入测试/最小权限/版本回滚/持续再认证（各配小图标：闸门/锁/回滚箭头/循环听诊器）；角标英文四原语 | 列表逐项点亮 |
 | 5-F 45° 定律 | p5-27..28 | 双曲线爬坡图：能力线（金）与安全线（青）同步 45° 上升；分叉警示虚影（能力甩开安全）；角标 AI-45° Law | 双线同步爬升 + 分叉闪警 |
 
@@ -83,8 +85,9 @@
 | 6-B2 闭环复盘 | p6-06a..06d | 五节点环形流水：部署轨迹（金点流）→ 经验编译器（站点命名角标 Experience Compiler：选证据/提抽象/记出处三步徽标）→ 分双路：工位侧快路（青，标注「快/可逆」）与大脑侧慢路（紫，标注「慢/持久」）→ 评测+安全闸门（红描边）→ 回到部署；末端标签「受控的持久能力」 | 环形流光巡游 + 青路快闪/紫路慢沉双速差 + 闸门脉冲 |
 | 6-C 总收束 | p6-07 | 金句卡补完：「接住、归档、验证、再变成实力」四步短语逐一下划线 | 下划线扫描 |
 | 6-D 三块拼图 | p6-08..10 | 三个拼图槽依次落位：可靠反馈/安全自改架构/评测=持续体检 | 拼图落位 |
-| 6-E 系列呼应 | p6-11..13 | 上一集《AI 如何自己变强？》封面卡淡入（蓝橙双色徽标），与本集（金青紫）并排 | 双卡并排 |
-| 6-F 配套清单卡 | p6-13a..13b | 仓库卡：Awesome-Self-Improving-Agents（mono 字体）+ 「111 篇 × 9 章」计数器滚动；九个章名小胶囊环绕（技能/记忆/环境/工具/参数/元进化/评测/安全/定义） | 计数器滚动 + 胶囊环绕弹出 |
+| 6-E 共同的地基 | p6-11..13 | 九个开放问题小面板（反枚举：不配九色）落成一排，共同压在宽金色基石「验证」上；末句左侧青色能力曲线陡升、基石厚度只微增——"scales least well" 的画面 | 面板降落 + 基石亮金 + 曲线对比 |
+| 6-F 配套清单卡 | p6-13a..13b | 仓库卡：Awesome-Self-Improving-Agents（mono 字体）+ 「331 篇 × 9 章」计数器滚动 + 取数日期行；九个章名小胶囊环绕（引言/工位/技能/记忆/环境/大脑/元进化/评测/安全） | 计数器滚动 + 胶囊环绕弹出 |
+| 6-F2 三条曲线 | p6-13c..13d | 同一坐标轴三条候选轨迹（全金色、线型区分：实线上扬=利滚利/虚线平台=撞到顶/点线正弦=原地震荡），各以衬线？收尾；角标 not known to compound, saturate, or oscillate（§10） | 轴生长 + 三线描画 + 问号渐显 |
 | 6-G 原文卡 | p6-14..15 | 论文引用卡：标题 + 清华大学 × Frontis.AI + 2026-06；「推荐读原文」；渐黑 | 卡片停留 + 渐黑（时长从末 beat 实时推导） |
 
 ## 字幕规范
diff --git a/media/experience-era-agents-video/video/package.json b/media/experience-era-agents-video/video/package.json
index 0b60405fa..36c1d75d9 100644
--- a/media/experience-era-agents-video/video/package.json
+++ b/media/experience-era-agents-video/video/package.json
@@ -10,6 +10,8 @@
   },
   "dependencies": {
     "@remotion/cli": "^4.0.0",
+    "@remotion/layout-utils": "4.0.512",
+    "@remotion/media": "4.0.512",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
     "remotion": "^4.0.0"
diff --git a/media/experience-era-agents-video/video/pnpm-lock.yaml b/media/experience-era-agents-video/video/pnpm-lock.yaml
index a9815bab6..d37f0e832 100644
--- a/media/experience-era-agents-video/video/pnpm-lock.yaml
+++ b/media/experience-era-agents-video/video/pnpm-lock.yaml
@@ -11,6 +11,12 @@ importers:
       '@remotion/cli':
         specifier: ^4.0.0
         version: 4.0.512(postcss@8.5.26)(react-dom@19.2.8(react@19.2.8))(react@19.2.8)(supports-color@8.1.1)(typescript@5.9.3)
+      '@remotion/layout-utils':
+        specifier: 4.0.512
+        version: 4.0.512
+      '@remotion/media':
+        specifier: 4.0.512
+        version: 4.0.512(react-dom@19.2.8(react@19.2.8))(react@19.2.8)
       react:
         specifier: ^19.0.0
         version: 19.2.8
@@ -381,6 +387,9 @@ packages:
     cpu: [x64]
     os: [win32]
 
+  '@remotion/layout-utils@4.0.512':
+    resolution: {integrity: sha512-ZJpRRQ54UHGrTW4g3/mzwfTftaXK779SXM5TOXnhS2Bh4JaImmDfvK1cUGIJu4lAOgMZsvLva+E6SqjzDt1qiw==}
+
   '@remotion/licensing@4.0.512':
     resolution: {integrity: sha512-TRDcdvgQXOxC12A/hu1VlTzt9CqIQr2RrhlL9kODgbqOEjefK1fS4EJY+PsmpxBcQqTI4+pw3KHbo9NkddPLfg==}
 
@@ -393,6 +402,12 @@ packages:
       react: '>=16.8.0'
       react-dom: '>=16.8.0'
 
+  '@remotion/media@4.0.512':
+    resolution: {integrity: sha512-/VmCY0D0KiXXqjQGOy2Mh/CtG9gPRpbWsIin/g/oBbosFNpWGYRSAB9gL+6wx4mPHeonSGMCyJMKyXVmm83FeQ==}
+    peerDependencies:
+      react: '>=16.8.0'
+      react-dom: '>=16.8.0'
+
   '@remotion/player@4.0.512':
     resolution: {integrity: sha512-Brc+aqjIyEEkwLncTNMrQf8MkfS/HhOSJs7qpDfK68nqOu/u3ULOtdIIXGPArvS3TkSea1FUA2VxP+1vqXwY2g==}
     peerDependencies:
@@ -1668,6 +1683,8 @@ snapshots:
   '@remotion/compositor-win32-x64-msvc@4.0.512':
     optional: true
 
+  '@remotion/layout-utils@4.0.512': {}
+
   '@remotion/licensing@4.0.512': {}
 
   '@remotion/media-parser@4.0.512': {}
@@ -1679,6 +1696,14 @@ snapshots:
       react-dom: 19.2.8(react@19.2.8)
       remotion: 4.0.512(react-dom@19.2.8(react@19.2.8))(react@19.2.8)
 
+  '@remotion/media@4.0.512(react-dom@19.2.8(react@19.2.8))(react@19.2.8)':
+    dependencies:
+      mediabunny: 1.50.8
+      react: 19.2.8
+      react-dom: 19.2.8(react@19.2.8)
+      remotion: 4.0.512(react-dom@19.2.8(react@19.2.8))(react@19.2.8)
+      zod: 4.4.3
+
   '@remotion/player@4.0.512(react-dom@19.2.8(react@19.2.8))(react@19.2.8)':
     dependencies:
       react: 19.2.8
diff --git a/media/experience-era-agents-video/video/remotion.config.ts b/media/experience-era-agents-video/video/remotion.config.ts
index dcbd61570..a5b5e8e5c 100644
--- a/media/experience-era-agents-video/video/remotion.config.ts
+++ b/media/experience-era-agents-video/video/remotion.config.ts
@@ -1,4 +1,14 @@
 import {Config} from '@remotion/cli/config';
 
-Config.setVideoImageFormat('jpeg');
+Config.setVideoImageFormat('jpeg'); // jpeg 显著快于 png（无透明需求）
 Config.setOverwriteOutput(true);
+// —— 交付硬化（B 站/YouTube）——
+Config.setCodec('h264'); // 平台通吃；h265 经平台二压反而更差
+Config.setCrf(18); // h264 视觉无损档
+Config.setPixelFormat('yuv420p'); // 兼容基线（yuv444p 部分解码器不支持）
+Config.setAudioCodec('aac');
+Config.setAudioBitrate('192K'); // 单人旁白透明
+Config.setEnforceAudioTrack(true); // 缺音频也出静音轨，防平台拒收无音轨文件
+Config.setJpegQuality(90); // 终渲；草渲由 CLI --jpeg-quality=60 覆盖
+// 注意：不设 setConcurrency——并发度是机器属性，写入三集共享文件正是要消灭的
+// 漂移类型；渲染主机应先 npx remotion benchmark 再以 CLI --concurrency=N 传入。
diff --git a/media/experience-era-agents-video/video/src/Main.tsx b/media/experience-era-agents-video/video/src/Main.tsx
index c582b938b..4f3aee0c8 100644
--- a/media/experience-era-agents-video/video/src/Main.tsx
+++ b/media/experience-era-agents-video/video/src/Main.tsx
@@ -1,9 +1,10 @@
 import React from 'react';
 import {AbsoluteFill, Sequence} from 'remotion';
 import {NarrationAudio} from './components/NarrationAudio';
+import {SceneFade} from './components/SceneFade';
 import {Subtitle} from './components/Subtitle';
 import {theme} from './design/theme';
-import {computeTimeline} from './timing';
+import {computeTimeline, SCENE_FADE_FRAMES} from './timing';
 import type {ManifestItem, SceneRange} from './types';
 import {P0Hook} from './scenes/P0Hook';
 import {P1Anatomy} from './scenes/P1Anatomy';
@@ -29,14 +30,22 @@ export const Main: React.FC<MainProps> = ({manifest}) => {
   const {timed, scenes} = computeTimeline(manifest);
   return (
     <AbsoluteFill style={{background: theme.bg}}>
-      {scenes.map((sc) => {
+      {scenes.map((sc, i) => {
         const SceneComp = SCENE_COMPONENTS[sc.scene];
         if (!SceneComp) {
           throw new Error(`未注册的场景组件: ${sc.scene}`);
         }
         return (
           <Sequence key={sc.scene} from={sc.from} durationInFrames={sc.durationInFrames} name={sc.scene}>
-            <SceneComp scene={sc} />
+            {/* 幕间呼吸淡入淡出：只花幕间既有静默，from/总时长零改动；首幕不淡入、
+                末幕不淡出（尾幕渐黑由 P6 从末 beat 推导，叠加成双重渐黑） */}
+            <SceneFade
+              durationInFrames={sc.durationInFrames}
+              fadeIn={i === 0 ? 0 : SCENE_FADE_FRAMES}
+              fadeOut={i === scenes.length - 1 ? 0 : SCENE_FADE_FRAMES}
+            >
+              <SceneComp scene={sc} />
+            </SceneFade>
           </Sequence>
         );
       })}
diff --git a/media/experience-era-agents-video/video/src/components/NarrationAudio.tsx b/media/experience-era-agents-video/video/src/components/NarrationAudio.tsx
index 0555863f4..3f7a04132 100644
--- a/media/experience-era-agents-video/video/src/components/NarrationAudio.tsx
+++ b/media/experience-era-agents-video/video/src/components/NarrationAudio.tsx
@@ -1,16 +1,30 @@
 import React from 'react';
-import {Audio, Sequence, staticFile} from 'remotion';
+import {Audio} from '@remotion/media';
+import {staticFile} from 'remotion';
 import type {TimedSentence} from '../types';
 
-/** 全片旁白：每句一段音频，按 manifest 时序装配 */
-export const NarrationAudio: React.FC<{timed: TimedSentence[]}> = ({timed}) => {
-  return (
-    <>
-      {timed.map((s) => (
-        <Sequence key={s.id} from={s.from} durationInFrames={s.durationInFrames} name={`audio:${s.id}`}>
-          <Audio src={staticFile(`audio/${s.id}.mp3`)} />
-        </Sequence>
-      ))}
-    </>
-  );
-};
+/**
+ * 预览期提前 1s 挂载缓冲；渲染期 Remotion 自动关闭 premount（active 含
+ * !env.isRendering——收益只在 Studio 拖拽与 Player，渲染侧收益是 Mediabunny
+ * 抽轨与官方声明的时间轴同步，不是渲染速度。见 skills/06 事实条）。
+ */
+const PREMOUNT_FRAMES = 30;
+
+/** 全片旁白：每句一段音频，按 manifest 绝对帧位装配（时间轴与视觉层解耦）。
+ *  @remotion/media 的 <Audio> 原生带 from/durationInFrames，无须外包 <Sequence>——
+ *  premountFor 挂在「尚未开始的 Sequence」子节点上不会触发。失败默认回落
+ *  <Html5Audio>（更稳），缺 manifest 的报错在 Root.tsx calculateMetadata。 */
+export const NarrationAudio: React.FC<{timed: TimedSentence[]}> = ({timed}) => (
+  <>
+    {timed.map((s) => (
+      <Audio
+        key={s.id}
+        name={`audio:${s.id}`}
+        src={staticFile(`audio/${s.id}.mp3`)}
+        from={s.from}
+        durationInFrames={s.durationInFrames}
+        premountFor={PREMOUNT_FRAMES}
+      />
+    ))}
+  </>
+);
diff --git a/media/experience-era-agents-video/video/src/components/SceneFade.tsx b/media/experience-era-agents-video/video/src/components/SceneFade.tsx
new file mode 100644
index 000000000..6e7bc20d7
--- /dev/null
+++ b/media/experience-era-agents-video/video/src/components/SceneFade.tsx
@@ -0,0 +1,41 @@
+import React from 'react';
+import {AbsoluteFill, interpolate, useCurrentFrame} from 'remotion';
+
+/**
+ * 幕间呼吸淡入淡出——只花 timing.json 已声明的幕间静默（句间 0.32s + 幕间 0.9s），
+ * 不改任何 Sequence 的 from 与总时长，音频层零风险。
+ *
+ * 为什么不用 @remotion/transitions 的 TransitionSeries：其总时长 = Σ序列 − Σ转场，
+ * 会把视觉层整体左移而旁白（按 manifest 帧号绝对定位的独立层）不动，产生逐幕
+ * 递增的失同步。见 media/pipeline/skills/06-remotion-implementation.md。
+ *
+ * 用法（Main.tsx 的 scenes.map 内包一层）：
+ *   <SceneFade durationInFrames={sc.durationInFrames}
+ *              fadeIn={i === 0 ? 0 : SCENE_FADE_FRAMES}
+ *              fadeOut={i === scenes.length - 1 ? 0 : SCENE_FADE_FRAMES}>
+ *     <SceneComp scene={sc} />
+ *   </SceneFade>
+ * 首幕不淡入（LEAD_IN 0.6s 本就黑场）；末幕不淡出（尾幕渐黑由 P6 从末 beat 推导，
+ * 叠加会成双重渐黑——上线教训见 skills/06 清单第 4 条）。
+ * 三集逐字节一致（冻结清单成员）。不变式由 check_script.py 强制：
+ * 2 × sceneCrossFadeSec ≤ sentenceGapSec + sceneGapSec。
+ */
+export const SceneFade: React.FC<{
+  durationInFrames: number;
+  fadeIn: number;
+  fadeOut: number;
+  children: React.ReactNode;
+}> = ({durationInFrames, fadeIn, fadeOut, children}) => {
+  const frame = useCurrentFrame();
+  const inOp = fadeIn
+    ? interpolate(frame, [0, fadeIn], [0, 1], {extrapolateRight: 'clamp'})
+    : 1;
+  const outOp = fadeOut
+    ? interpolate(frame, [durationInFrames - fadeOut, durationInFrames], [1, 0], {
+        extrapolateLeft: 'clamp',
+      })
+    : 1;
+  return (
+    <AbsoluteFill style={{opacity: Math.min(inOp, outOp)}}>{children}</AbsoluteFill>
+  );
+};
diff --git a/media/experience-era-agents-video/video/src/components/Subtitle.tsx b/media/experience-era-agents-video/video/src/components/Subtitle.tsx
index ac3b4b78a..d34a3f3df 100644
--- a/media/experience-era-agents-video/video/src/components/Subtitle.tsx
+++ b/media/experience-era-agents-video/video/src/components/Subtitle.tsx
@@ -1,14 +1,21 @@
 import React from 'react';
 import {AbsoluteFill, interpolate, useCurrentFrame} from 'remotion';
+import {fitText} from '@remotion/layout-utils';
 import {theme} from '../design/theme';
 import type {TimedSentence} from '../types';
 
-const CJK = /[⺀-鿿豈-﫿]/;
-/** 全角标点与 CJK 同宽（1em），不满足 CJK 区间，须并列判定；
- *  ASCII 引号 (U+0022/27) 字形实为半宽，不入此类、按 0.55 桶计 */
-const FULLWIDTH_PUNCT = /[，。！？：；、“”‘’（）——…·《》「」]/;
+const MAX_WIDTH = 1600;
+const PADDING_X = 36;
+/** Remotion 默认样式表为 box-sizing: border-box，内容预算须减去左右 padding */
+const CONTENT_WIDTH = MAX_WIDTH - PADDING_X * 2;
+const MAX_FONT_SIZE = 44;
+const MIN_FONT_SIZE = 30;
 
-/** 全片底部字幕条：一句一条，与配音逐句同步（storyboard.md 字幕规范） */
+/** 全片底部字幕条：一句一条，与配音逐句同步（storyboard.md 字幕规范）。
+ *  字号用 @remotion/layout-utils 的 fitText 真实测量（替代此前手写的全角 1.0/半角
+ *  0.55 宽度估算与魔法阈值）。validateFontIsLoaded 保持 4.x 默认 false——系统字体
+ *  栈无 loadFont() promise 可等；⚠️ Remotion 5.0 起该开关默认翻 true，届时若仍未
+ *  内嵌字体会开始抛错（重启触发器见 pipeline/README 字体约束节）。 */
 export const Subtitle: React.FC<{timed: TimedSentence[]}> = ({timed}) => {
   const frame = useCurrentFrame();
   const current = timed.find((s) => frame >= s.from && frame < s.from + s.durationInFrames);
@@ -19,21 +26,20 @@ export const Subtitle: React.FC<{timed: TimedSentence[]}> = ({timed}) => {
   const opacity = interpolate(local, [0, 4], [0, 1], {
     extrapolateRight: 'clamp',
   });
-  // 长句防御性收缩：估算宽度超限时缩小字号，保证单行不溢出（全角≈1 字宽，半角≈0.55）。
-  // 内容预算 = maxWidth 1600 − 左右 padding 72 = 1528，估算含 ~2% 字距余量故用 1500 触发
-  const estWidth =
-    current.text.split('').reduce(
-      (w, ch) => w + (CJK.test(ch) || FULLWIDTH_PUNCT.test(ch) ? 1 : 0.55),
-      0,
-    ) * 44;
-  const fontSize = estWidth > 1500 ? Math.max(30, 44 - (estWidth - 1500) / 25) : 44;
+  const fitted = fitText({
+    text: current.text,
+    withinWidth: CONTENT_WIDTH,
+    fontFamily: theme.sans,
+    fontWeight: 500, // 须与下方 div 的 fontWeight 一致，否则测量偏小
+  }).fontSize;
+  const fontSize = Math.max(MIN_FONT_SIZE, Math.min(MAX_FONT_SIZE, fitted));
   return (
     <AbsoluteFill style={{justifyContent: 'flex-end', alignItems: 'center', pointerEvents: 'none'}}>
       <div
         style={{
           marginBottom: 54,
-          maxWidth: 1600,
-          padding: '12px 36px',
+          maxWidth: MAX_WIDTH,
+          padding: `12px ${PADDING_X}px`,
           borderRadius: 12,
           background: 'rgba(6, 8, 12, 0.68)',
           color: theme.text,
diff --git a/media/experience-era-agents-video/video/src/scenes/P1Anatomy.tsx b/media/experience-era-agents-video/video/src/scenes/P1Anatomy.tsx
index c3a798014..c139ffdb7 100644
--- a/media/experience-era-agents-video/video/src/scenes/P1Anatomy.tsx
+++ b/media/experience-era-agents-video/video/src/scenes/P1Anatomy.tsx
@@ -416,6 +416,49 @@ const ThreeGens: React.FC<{gen3At: number}> = ({gen3At}) => {
             borderRadius: 3,
           }}
         />
+        {/* Figure 3 的 11 个带日期里程碑（约四年半）：刻度随时间轴展开依次点亮 */}
+        {[
+          ['21-12', 'WebGPT'], ['22-10', 'ReAct'], ['23-03', 'Reflexion'], ['23-08', 'AutoGen'],
+          ['24-01', 'LangGraph'], ['24-05', 'SWE-agent'], ['24-07', 'OpenHands'], ['25-02', 'Claude Code'],
+          ['25-05', 'Codex'], ['26-02', 'OpenClaw'], ['26-04', 'Cursor 3'],
+        ].map(([date, name], i) => {
+          const t = (i + 0.5) / 11;
+          // 帧驱动渐显（0.85 目标值），不写 CSS transition——渲染侧截图相位须确定
+          const on = interpolate(frame, [12 + i * 7, 21 + i * 7], [0, 0.85], {
+            extrapolateLeft: 'clamp',
+            extrapolateRight: 'clamp',
+          });
+          return (
+            <div
+              key={name}
+              style={{
+                position: 'absolute',
+                top: 14,
+                left: `${t * 100}%`,
+                transform: 'translateX(-50%)',
+                textAlign: 'center',
+                opacity: on,
+              }}
+            >
+              <div style={{width: 2, height: 12, background: theme.dim, margin: '0 auto'}} />
+              <div style={{fontFamily: theme.mono, fontSize: 13, color: theme.dim, marginTop: 2}}>{date}</div>
+              <div style={{fontFamily: theme.sans, fontSize: 15, color: theme.text}}>{name}</div>
+            </div>
+          );
+        })}
+        <div
+          style={{
+            position: 'absolute',
+            top: -26,
+            right: 0,
+            fontFamily: theme.sans,
+            fontSize: 19,
+            color: theme.exp,
+            opacity: interpolate(frame, [96, 112], [0, 1], {extrapolateLeft: 'clamp', extrapolateRight: 'clamp'}),
+          }}
+        >
+          任务循环 → 部署运行时自适应 · 约四年半
+        </div>
         <div style={{display: 'flex', gap: 60, marginTop: 90, alignItems: 'flex-start'}}>
           {gens.map((g, i) => {
             const enter = spring({frame: frame - i * 16, fps, config: {damping: 200}});
diff --git a/media/experience-era-agents-video/video/src/scenes/P2FourDestinations.tsx b/media/experience-era-agents-video/video/src/scenes/P2FourDestinations.tsx
index 21b99abd3..897685d09 100644
--- a/media/experience-era-agents-video/video/src/scenes/P2FourDestinations.tsx
+++ b/media/experience-era-agents-video/video/src/scenes/P2FourDestinations.tsx
@@ -423,11 +423,52 @@ const EnvFloors: React.FC = () => {
           </div>
         </div>
       </div>
-      <FadeUp delay={60} style={{marginTop: 54}}>
+      <FadeUp delay={60} style={{marginTop: 44}}>
         <div style={{fontFamily: theme.sans, fontSize: 27, color: theme.dim}}>
-          大部分环境卡在一楼半：能跑，但反馈太稀、没法学
+          就算能跑、接口也通了，反馈却稀得没法学（§5.4）
         </div>
       </FadeUp>
+      {/* 三条天花板轴（Fig 6）：p2-32 时标尺扫入，p2-32a 三条依次生长且都停在天花板前 */}
+      <div style={{marginTop: 34, display: 'flex', flexDirection: 'column', gap: 14, alignItems: 'center'}}>
+        {[
+          {label: '能动的花样', fill: 0.86},
+          {label: '反馈的密度', fill: 0.42},
+          {label: '任务的长度', fill: 0.64},
+        ].map((axis, i) => {
+          const e = interpolate(frame, [86 + i * 10, 106 + i * 10], [0, 1], {
+            extrapolateLeft: 'clamp', extrapolateRight: 'clamp',
+          });
+          return (
+            <div key={axis.label} style={{display: 'flex', alignItems: 'center', gap: 16}}>
+              <span style={{width: 130, textAlign: 'right', fontFamily: theme.sans, fontSize: 21, color: theme.text}}>
+                {axis.label}
+              </span>
+              <div
+                style={{
+                  width: 460,
+                  height: 20,
+                  borderRadius: 10,
+                  background: theme.panel,
+                  border: `1.5px solid ${theme.panelBorder}`,
+                  overflow: 'hidden',
+                }}
+              >
+                <div
+                  style={{
+                    width: `${axis.fill * e * 100}%`,
+                    height: '100%',
+                    background: theme.exp,
+                    opacity: 0.82,
+                  }}
+                />
+              </div>
+            </div>
+          );
+        })}
+        <div style={{fontFamily: theme.mono, fontSize: 16, color: theme.dim, opacity: interpolate(frame, [118, 132], [0, 1], {extrapolateLeft: 'clamp', extrapolateRight: 'clamp'})}}>
+          action diversity · feedback density · task horizon（Fig 6）
+        </div>
+      </div>
     </AbsoluteFill>
   );
 };
@@ -575,6 +616,106 @@ const IndustryReality: React.FC = () => {
   );
 };
 
+/** 2-J：晋升闸门（v3 新增）——§10.2 "With no promotion criterion, the decision of
+ *  what to write to the weights rests on manual judgment." 的画面化：
+ *  左半青色 = 工位侧快路（钥匙只对上五把锁中的一把）；右半紫色 = 大脑侧慢路
+ *  （能力随身带走）；中间闸门的判准铭牌是**空白**（红问号脉冲），按下按钮后
+ *  紫侧点亮、闸下画出单向红箭头「很难逆转」。 */
+const PromotionGate: React.FC = () => {
+  const frame = useCurrentFrame();
+  const plateIn = interpolate(frame, [4, 18], [0, 1], {extrapolateLeft: 'clamp', extrapolateRight: 'clamp'});
+  const pulse = 0.5 + 0.5 * Math.sin(frame * 0.14);
+  const press = interpolate(frame, [66, 74], [0, 1], {extrapolateLeft: 'clamp', extrapolateRight: 'clamp'});
+  const oneWay = interpolate(frame, [78, 96], [0, 1], {extrapolateLeft: 'clamp', extrapolateRight: 'clamp'});
+  return (
+    <AbsoluteFill style={{justifyContent: 'center', alignItems: 'center'}}>
+      <div style={{display: 'flex', alignItems: 'stretch', gap: 0}}>
+        {/* 左：工位侧（青）——改 harness 像换触发条件 */}
+        <div style={{width: 430, padding: '30px 28px', background: theme.panel, borderRadius: '16px 0 0 16px', border: `2px solid ${theme.harness}55`}}>
+          <div style={{fontFamily: theme.sans, fontSize: 26, fontWeight: 700, color: theme.harness}}>工位 · 快 / 可逆</div>
+          <div style={{marginTop: 22, display: 'flex', gap: 10, justifyContent: 'center'}}>
+            {[1, 0, 0, 0, 0].map((on, i) => (
+              <div key={i} style={{width: 38, height: 50, borderRadius: 7, background: on ? theme.harness : theme.panel, border: `1.5px solid ${on ? theme.harness : theme.panelBorder}`, opacity: on ? 1 : 0.55}} />
+            ))}
+          </div>
+          <div style={{marginTop: 14, fontFamily: theme.sans, fontSize: 20, color: theme.dim, textAlign: 'center'}}>
+            换个条件就能生效
+          </div>
+        </div>
+        {/* 中：闸门——判准铭牌空白 */}
+        <div style={{width: 300, display: 'flex', flexDirection: 'column', alignItems: 'center', justifyContent: 'center', background: '#10141d', borderTop: `2px solid ${theme.panelBorder}`, borderBottom: `2px solid ${theme.panelBorder}`}}>
+          <div
+            style={{
+              width: 190,
+              height: 84,
+              borderRadius: 10,
+              background: '#0c0f16',
+              border: `2px dashed ${theme.danger}88`,
+              display: 'flex',
+              justifyContent: 'center',
+              alignItems: 'center',
+              opacity: plateIn,
+            }}
+          >
+            <span style={{fontSize: 40, color: theme.danger, opacity: 0.35 + 0.65 * pulse}}>?</span>
+          </div>
+          <div style={{marginTop: 10, fontFamily: theme.mono, fontSize: 15, color: theme.danger, opacity: plateIn}}>
+            promotion criterion: absent（§10.2）
+          </div>
+          {/* 按钮 */}
+          <div
+            style={{
+              marginTop: 16,
+              width: 54,
+              height: 54,
+              borderRadius: 27,
+              background: press > 0 ? theme.danger : '#2a1418',
+              border: `2px solid ${theme.danger}`,
+              transform: `scale(${1 - 0.18 * press})`,
+              boxShadow: press > 0 ? `0 0 26px ${theme.danger}66` : 'none',
+            }}
+          />
+        </div>
+        {/* 右：大脑侧（紫）——能力随身带走 */}
+        <div style={{width: 430, padding: '30px 28px', background: theme.panel, borderRadius: '0 16px 16px 0', border: `2px solid ${press > 0 ? theme.params : theme.panelBorder}`}}>
+          <div style={{fontFamily: theme.sans, fontSize: 26, fontWeight: 700, color: theme.params, opacity: 0.55 + 0.45 * press}}>大脑 · 慢 / 持久</div>
+          <div style={{marginTop: 20, display: 'flex', justifyContent: 'center'}}>
+            <div
+              style={{
+                width: 92,
+                height: 92,
+                borderRadius: 46,
+                background: `radial-gradient(circle, ${theme.params}44 0%, transparent 70%)`,
+                border: `2.5px solid ${theme.params}`,
+                display: 'flex',
+                justifyContent: 'center',
+                alignItems: 'center',
+                fontSize: 44,
+                opacity: 0.45 + 0.55 * press,
+              }}
+            >
+              🧠
+            </div>
+          </div>
+          <div style={{marginTop: 14, fontFamily: theme.sans, fontSize: 20, color: theme.dim, textAlign: 'center', opacity: 0.6 + 0.4 * press}}>
+            写进去，跨任务都带得走
+          </div>
+        </div>
+      </div>
+      {/* 单向箭头：很难逆转 */}
+      <svg width={620} height={54} style={{marginTop: 24}}>
+        <line x1={30} y1={20} x2={30 + 540 * oneWay} y2={20} stroke={theme.danger} strokeWidth={4} strokeLinecap="round" />
+        {oneWay > 0.96 ? (
+          <polygon points={`${30 + 540},${20} ${30 + 516},${8} ${30 + 516},${32}`} fill={theme.danger} />
+        ) : null}
+        <text x={30} y={46} fill={theme.danger} fontSize={19} fontFamily={theme.sans} opacity={oneWay}>
+          很难逆转
+        </text>
+      </svg>
+    </AbsoluteFill>
+  );
+};
+
 export const P2FourDestinations: React.FC<{scene: SceneRange}> = ({scene}) => {
   const w = (fromId: string, toId?: string) => beatWindow(scene.sentences, scene.from, fromId, toId);
   return (
@@ -606,6 +747,9 @@ export const P2FourDestinations: React.FC<{scene: SceneRange}> = ({scene}) => {
       <Sequence {...w('p2-42', 'p2-47')} name="2-I 工业现实">
         <IndustryReality />
       </Sequence>
+      <Sequence {...w('p2-47a', 'p2-47b')} name="2-J 晋升闸门">
+        <PromotionGate />
+      </Sequence>
     </AbsoluteFill>
   );
 };
diff --git a/media/experience-era-agents-video/video/src/scenes/P3Meta.tsx b/media/experience-era-agents-video/video/src/scenes/P3Meta.tsx
index a755f9612..8c6671f5e 100644
--- a/media/experience-era-agents-video/video/src/scenes/P3Meta.tsx
+++ b/media/experience-era-agents-video/video/src/scenes/P3Meta.tsx
@@ -13,6 +13,15 @@ import {beatWindow} from '../timing';
 import type {SceneRange} from '../types';
 
 /** 3-A：三级阶梯 + 谁控制进化 */
+// Figure 8 格阵落格（行×列展开，与下方 cols/rows 同序）：MetaMem=7.3.1（meta 层控制·记忆
+// 机制）、MetaEvo/SkillOS=7.3.2（meta 层控制·改进策略）、Hyperagents=7.3.3（meta 层控制·
+// 元层自身）；SkillClaw=Fig8 第一列（任务体自控·内容资产）、SkillRL=7.2.2（任务体自控·
+// 改进策略）；任务体自控×机制列（7.2.1）无本片点名的范例，留 '…' 通配。
+const GRID_CELLS = [
+  '', 'MetaMem', 'MetaEvo · SkillOS', 'Hyperagents',
+  'SkillClaw 系', '…', 'SkillRL', '',
+];
+
 const Ladder: React.FC = () => {
   const frame = useCurrentFrame();
   const {fps} = useVideoConfig();
@@ -21,12 +30,69 @@ const Ladder: React.FC = () => {
     {name: '学会怎么改进', icon: '🧭', desc: '失败 → 原则 → 下次引用'},
     {name: '专职进化部门', icon: '🏛️', desc: '独立的 meta 层管进化'},
   ];
+  // Figure 8 二维格阵 underlay：先以淡格阵出现（p3-01..02），轴标签随 p3-03 点亮，
+  // 再让位给三级阶梯（A4 校准：1↔2 级分界是「改什么」，2↔3 才是控制权）
+  const grid = interpolate(frame, [6, 22], [0, 1], {extrapolateLeft: 'clamp', extrapolateRight: 'clamp'});
+  const axes = interpolate(frame, [28, 44], [0, 1], {extrapolateLeft: 'clamp', extrapolateRight: 'clamp'});
+  const toLadder = interpolate(frame, [48, 66], [0, 1], {extrapolateLeft: 'clamp', extrapolateRight: 'clamp'});
+  const cols = ['内容资产', '机制/结构', '改进策略', '元层自身'];
+  const rows = ['meta 层控制', '任务体自控'];
   return (
     <AbsoluteFill style={{justifyContent: 'center', alignItems: 'center'}}>
       <FadeUp style={{position: 'absolute', top: 110}}>
         <div style={{fontFamily: theme.sans, fontSize: 38, color: theme.exp}}>谁来决定，经验往哪送？</div>
       </FadeUp>
-      <div style={{display: 'flex', alignItems: 'flex-end', gap: 60, marginTop: 80}}>
+      {/* 二维格阵（Figure 8）：2 行 × 4 列，对角两格为空（–） */}
+      <div
+        style={{
+          position: 'absolute',
+          opacity: grid * (1 - toLadder),
+          transform: `translateY(${toLadder * 90}px) scale(${1 - 0.12 * toLadder})`,
+        }}
+      >
+        <div style={{display: 'grid', gridTemplateColumns: `repeat(4, 190px)`, gap: 10, marginLeft: 150}}>
+          {cols.map((c) => (
+            <div key={c} style={{textAlign: 'center', fontFamily: theme.mono, fontSize: 17, color: theme.harness, opacity: axes}}>
+              {c}
+            </div>
+          ))}
+        </div>
+        {rows.map((r, ri) => (
+          <div key={r} style={{display: 'grid', gridTemplateColumns: '140px repeat(4, 190px)', gap: 10, marginTop: 10, alignItems: 'center'}}>
+            <div style={{textAlign: 'right', fontFamily: theme.mono, fontSize: 17, color: theme.harness, opacity: axes}}>{r}</div>
+            {cols.map((c, ci) => {
+              // 对角两格为空（–）：meta 层×内容资产（§7.3 判据下内容资产归任务体自管）与
+              // 任务体×元层自身（元层自身只能由 meta 层进化）是分类法上的空格
+              const empty = (ri === 0 && ci === 0) || (ri === 1 && ci === 3);
+              const cellIn = interpolate(frame, [10 + (ri * 4 + ci) * 2, 20 + (ri * 4 + ci) * 2], [0, 1], {
+                extrapolateLeft: 'clamp',
+                extrapolateRight: 'clamp',
+              });
+              return (
+                <div
+                  key={c}
+                  style={{
+                    height: 108,
+                    borderRadius: 10,
+                    background: empty ? 'transparent' : theme.panel,
+                    border: `1.5px dashed ${empty ? theme.panelBorder : theme.harness}`,
+                    display: 'flex',
+                    justifyContent: 'center',
+                    alignItems: 'center',
+                    fontFamily: empty ? theme.mono : theme.sans,
+                    fontSize: empty ? 26 : 19,
+                    color: theme.dim,
+                    opacity: cellIn * (empty ? 0.6 : 1),
+                  }}
+                >
+                  {empty ? '–' : GRID_CELLS[ri * 4 + ci]}
+                </div>
+              );
+            })}
+          </div>
+        ))}
+      </div>
+      <div style={{display: 'flex', alignItems: 'flex-end', gap: 60, marginTop: 80, opacity: toLadder}}>
         {levels.map((l, i) => {
           const h = 200 + i * 110;
           const enter = spring({frame: frame - i * 12, fps, config: {damping: 200}});
diff --git a/media/experience-era-agents-video/video/src/scenes/P4Eval.tsx b/media/experience-era-agents-video/video/src/scenes/P4Eval.tsx
index 990f49e38..c39cc5e1b 100644
--- a/media/experience-era-agents-video/video/src/scenes/P4Eval.tsx
+++ b/media/experience-era-agents-video/video/src/scenes/P4Eval.tsx
@@ -238,6 +238,40 @@ const Longitudinal: React.FC<{metersAt: number}> = ({metersAt}) => {
         <FadeUp delay={60} style={{position: 'absolute', right: 60, top: 300}}>
           <Pill color={theme.exp}>留着旧题 · 反复重考</Pill>
         </FadeUp>
+        {/* Figure 9 三分带：题目分三摞——replay（旧题重考）/ adapt（改进时用的新题，
+            记录实际用过的经验）/ held-out（从没见过的，专验真泛化——§8.3 的核心检验） */}
+        <div
+          style={{
+            position: 'absolute',
+            left: 80,
+            right: 80,
+            top: 330,
+            display: 'flex',
+            gap: 10,
+            opacity: interpolate(frame, [76, 92], [0, 1], {extrapolateLeft: 'clamp', extrapolateRight: 'clamp'}),
+          }}
+        >
+          {[
+            {name: 'replay · 旧题重考', w: '31%', c: theme.exp},
+            {name: 'adapt · 改进用的新题', w: '31%', c: theme.harness},
+            {name: 'held-out · 从没见过', w: '31%', c: theme.params},
+          ].map((seg) => (
+            <div
+              key={seg.name}
+              style={{
+                width: seg.w,
+                textAlign: 'center',
+                fontFamily: theme.mono,
+                fontSize: 17,
+                color: seg.c,
+                borderTop: `3px solid ${seg.c}`,
+                paddingTop: 6,
+              }}
+            >
+              {seg.name}
+            </div>
+          ))}
+        </div>
       </div>
       {/* 四仪表通电：p4-17「各考一轮」起逐个点亮（站点四指标问句的可视化） */}
       <div style={{display: 'flex', gap: 34, marginTop: 8}}>
@@ -332,7 +366,7 @@ const RotBench: React.FC = () => {
 
 export const P4Eval: React.FC<{scene: SceneRange}> = ({scene}) => {
   const w = (fromId: string, toId?: string) => beatWindow(scene.sentences, scene.from, fromId, toId);
-  const winD = w('p4-15', 'p4-18');
+  const winD = w('p4-15', 'p4-18a');
   const at = (id: string) => {
     const s = scene.sentences.find((x) => x.id === id);
     if (!s) {
diff --git a/media/experience-era-agents-video/video/src/scenes/P5Safety.tsx b/media/experience-era-agents-video/video/src/scenes/P5Safety.tsx
index 49ffec196..fc645267a 100644
--- a/media/experience-era-agents-video/video/src/scenes/P5Safety.tsx
+++ b/media/experience-era-agents-video/video/src/scenes/P5Safety.tsx
@@ -322,6 +322,122 @@ const FeedbackHack: React.FC = () => {
   );
 };
 
+
+/** 5-D2：对齐漂移（v3 新增，§9.2.3 + §9.2.5）——p5-21a 工具链组合攻击：
+ *  连接器/协议/工作流各件单独✓、拼线连出意外路径；p5-21b 四招汇入
+ *  「对齐漂移」罗盘，系统轮廓从实线渐虚（一步步偏出当初那套规矩）。 */
+const DriftLens: React.FC = () => {
+  const frame = useCurrentFrame();
+  const chain = ['连接器', '协议', '工作流'];
+  const chainIn = interpolate(frame, [4, 22], [0, 1], {extrapolateLeft: 'clamp', extrapolateRight: 'clamp'});
+  const pathIn = interpolate(frame, [26, 44], [0, 1], {extrapolateLeft: 'clamp', extrapolateRight: 'clamp'});
+  const compass = interpolate(frame, [52, 72], [0, 1], {extrapolateLeft: 'clamp', extrapolateRight: 'clamp'});
+  const fade = interpolate(frame, [76, 104], [1, 0.35], {extrapolateLeft: 'clamp', extrapolateRight: 'clamp'});
+  const stage2 = frame > 48;
+  return (
+    <AbsoluteFill style={{justifyContent: 'center', alignItems: 'center'}}>
+      {!stage2 ? (
+        <div style={{display: 'flex', alignItems: 'center', gap: 26, opacity: chainIn}}>
+          {chain.map((c, i) => (
+            <React.Fragment key={c}>
+              {i > 0 ? (
+                <svg width={70} height={30}>
+                  <line
+                    x1={6}
+                    y1={15}
+                    x2={6 + 58 * (pathIn > i / chain.length ? 1 : 0)}
+                    y2={15}
+                    stroke={theme.danger}
+                    strokeWidth={3}
+                  />
+                </svg>
+              ) : null}
+              <div
+                style={{
+                  padding: '14px 22px',
+                  borderRadius: 12,
+                  background: theme.panel,
+                  border: `2px solid ${theme.ok}`,
+                  fontFamily: theme.sans,
+                  fontSize: 24,
+                  color: theme.text,
+                }}
+              >
+                {c} ✓
+              </div>
+            </React.Fragment>
+          ))}
+          <svg width={80} height={30}>
+            <line x1={6} y1={15} x2={6 + 68 * pathIn} y2={15} stroke={theme.danger} strokeWidth={4} />
+            {pathIn > 0.95 ? <polygon points="74,15 62,8 62,22" fill={theme.danger} /> : null}
+          </svg>
+          <div
+            style={{
+              padding: '14px 20px',
+              borderRadius: 12,
+              background: '#1c1114',
+              border: `2px solid ${theme.danger}`,
+              fontFamily: theme.sans,
+              fontSize: 23,
+              color: theme.danger,
+              opacity: pathIn,
+            }}
+          >
+            没人预期的路径
+          </div>
+        </div>
+      ) : (
+        <div style={{display: 'flex', alignItems: 'center', gap: 70, opacity: compass}}>
+          {/* 四类攻击汇入罗盘 */}
+          {['技能投毒', '记忆投毒', '工具链', '反馈操纵'].map((t, i) => (
+            <div
+              key={t}
+              style={{
+                padding: '10px 18px',
+                borderRadius: 999,
+                border: `2px solid ${theme.danger}`,
+                color: theme.danger,
+                fontFamily: theme.sans,
+                fontSize: 21,
+                opacity: interpolate(frame, [52 + i * 5, 62 + i * 5], [0, 1], {
+                  extrapolateLeft: 'clamp',
+                  extrapolateRight: 'clamp',
+                }),
+              }}
+            >
+              {t}
+            </div>
+          ))}
+          {/* 罗盘 + 渐虚轮廓 */}
+          <svg width={300} height={300}>
+            <circle
+              cx={150}
+              cy={150}
+              r={120}
+              fill="none"
+              stroke={theme.exp}
+              strokeWidth={3}
+              strokeDasharray={frame > 76 ? `${14 * fade + 2} ${10}` : '0'}
+              opacity={fade}
+            />
+            <circle cx={150} cy={150} r={86} fill="none" stroke={theme.panelBorder} strokeWidth={2} />
+            <text x={150} y={144} textAnchor="middle" fill={theme.text} fontSize={30} fontFamily={theme.serif} fontWeight={700}>
+              对齐漂移
+            </text>
+            <text x={150} y={176} textAnchor="middle" fill={theme.dim} fontSize={17} fontFamily={theme.mono}>
+              alignment drift
+            </text>
+            {Array.from({length: 4}).map((_, i) => {
+              const a = (i * Math.PI) / 2 + Math.PI / 4 + frame * 0.012;
+              return <circle key={i} cx={150 + 120 * Math.cos(a)} cy={150 + 120 * Math.sin(a)} r={5} fill={theme.danger} />;
+            })}
+          </svg>
+        </div>
+      )}
+    </AbsoluteFill>
+  );
+};
+
 /** 5-E：四味药 */
 const FourRemedies: React.FC = () => {
   const frame = useCurrentFrame();
@@ -431,6 +547,9 @@ export const P5Safety: React.FC<{scene: SceneRange}> = ({scene}) => {
       <Sequence {...w('p5-19', 'p5-21')} name="5-D 反馈操纵">
         <FeedbackHack />
       </Sequence>
+      <Sequence {...w('p5-21a', 'p5-21b')} name="5-D2 对齐漂移">
+        <DriftLens />
+      </Sequence>
       <Sequence {...w('p5-22', 'p5-26')} name="5-E 四味药">
         <FourRemedies />
       </Sequence>
diff --git a/media/experience-era-agents-video/video/src/scenes/P6Ending.tsx b/media/experience-era-agents-video/video/src/scenes/P6Ending.tsx
index 352f8ff77..3c080c895 100644
--- a/media/experience-era-agents-video/video/src/scenes/P6Ending.tsx
+++ b/media/experience-era-agents-video/video/src/scenes/P6Ending.tsx
@@ -335,78 +335,174 @@ const ThreePuzzles: React.FC = () => {
   );
 };
 
-/** 6-E：系列呼应——上一集与本集并排 */
-const SeriesEcho: React.FC = () => {
+/** 6-E：共同的地基·验证——§10 收束论点的画面化（v3 替代原系列呼应卡）
+ *  九个开放问题（小面板，反枚举：不配九色）落成一排，共同压在金色基石「验证」上；
+ *  末句左侧青色能力曲线陡升、基石厚度只微增——"scales least well" 的视觉。 */
+const VerificationBedrock: React.FC = () => {
   const frame = useCurrentFrame();
   const {fps} = useVideoConfig();
-  const prev = spring({frame: frame - 6, fps, config: {damping: 200}});
-  const curr = spring({frame: frame - 20, fps, config: {damping: 200}});
+  const settle = spring({frame: frame - 4, fps, config: {damping: 200}});
+  const slabIn = ci(frame, 30, 48);
+  const labelIn = ci(frame, 44, 58);
+  const curveIn = ci(frame, 74, 116);
+  const tiles = ['激发?', '越吃越窄?', '多模态', '判据缺失', '弱反馈', '自产漂移', '纵向评测', '跨版本', '改元层'];
   return (
     <AbsoluteFill style={{justifyContent: 'center', alignItems: 'center'}}>
-      <div style={{display: 'flex', gap: 60, alignItems: 'center'}}>
-        <div
-          style={{
-            width: 480,
-            padding: 40,
-            borderRadius: 20,
-            background: theme.panel,
-            border: `3px solid #4A9EFF`,
-            opacity: prev * 0.92,
-            transform: `translateY(${(1 - prev) * 40}px)`,
-          }}
-        >
-          <div style={{display: 'flex', gap: 8, marginBottom: 18}}>
-            <span style={{width: 40, height: 8, borderRadius: 4, background: '#4A9EFF'}} />
-            <span style={{width: 40, height: 8, borderRadius: 4, background: '#FF9F45'}} />
-          </div>
-          <div style={{fontFamily: theme.sans, fontSize: 30, fontWeight: 700, color: theme.text}}>
-            上期：AI 如何自己变强？
-          </div>
-          <div style={{marginTop: 12, fontFamily: theme.sans, fontSize: 24, color: theme.dim, lineHeight: 1.6}}>
-            改大脑，还是改装备？
-            <br />
-            ——「改什么」
-          </div>
-        </div>
-        <div style={{fontSize: 50, color: theme.exp, opacity: curr}}>＋</div>
-        <div
-          style={{
-            width: 480,
-            padding: 40,
-            borderRadius: 20,
-            background: theme.panel,
-            border: `3px solid ${theme.exp}`,
-            opacity: curr,
-            transform: `translateY(${(1 - curr) * 40}px)`,
-            boxShadow: `0 0 70px ${theme.exp}22`,
-          }}
+      {/* 左侧能力曲线（青）：随末句陡升 */}
+      <svg width={300} height={360} style={{position: 'absolute', left: 150, top: 360, opacity: curveIn}}>
+        <path
+          d={`M 30 330 Q ${30 + 80 * curveIn} ${330 - 60 * curveIn}, ${30 + 240 * curveIn} ${330 - 280 * curveIn}`}
+          fill="none"
+          stroke={theme.harness}
+          strokeWidth={5}
+          strokeLinecap="round"
+        />
+        <text x={30} y={352} fill={theme.dim} fontSize={20} fontFamily={theme.sans}>
+          能力
+        </text>
+      </svg>
+      <div style={{display: 'flex', gap: 14, alignItems: 'flex-end', transform: `translateY(${(1 - settle) * 30}px)`, opacity: settle}}>
+        {tiles.map((t, i) => {
+          const e = ci(frame, 6 + i * 3, 16 + i * 3);
+          return (
+            <div
+              key={t}
+              style={{
+                width: 118,
+                height: 86,
+                borderRadius: 10,
+                background: theme.panel,
+                border: `1.5px solid ${theme.panelBorder}`,
+                display: 'flex',
+                justifyContent: 'center',
+                alignItems: 'center',
+                fontFamily: theme.sans,
+                fontSize: 19,
+                color: theme.dim,
+                opacity: e,
+                transform: `translateY(${(1 - e) * 22}px)`,
+              }}
+            >
+              {t}
+            </div>
+          );
+        })}
+      </div>
+      {/* 金色基石：验证——厚度几乎不长（对比左图能力曲线） */}
+      <div
+        style={{
+          marginTop: 26,
+          width: 1210,
+          height: 52 + 6 * labelIn, // 末句只微增 6px —— 这就是 "scales least well"
+          borderRadius: 8,
+          background: `linear-gradient(180deg, ${theme.exp}, ${theme.expDeep})`,
+          opacity: slabIn,
+          display: 'flex',
+          justifyContent: 'center',
+          alignItems: 'center',
+        }}
+      >
+        <span style={{fontFamily: theme.serif, fontSize: 30, fontWeight: 700, color: '#0E1116', opacity: labelIn}}>
+          验证
+        </span>
+      </div>
+      <div style={{marginTop: 18, fontFamily: theme.mono, fontSize: 17, color: theme.dim, opacity: curveIn}}>
+        &quot;the capacity that scales least well as agents become more capable&quot;（§10）
+      </div>
+    </AbsoluteFill>
+  );
+};
+
+/** 6-F2：三条曲线——§10 末段悬念 "not known to compound, saturate, or oscillate"。
+ *  三条候选轨迹全金色、以线型区分（反枚举不用三色）；描画用 pathLength（与 px 版
+ *  strokeDasharray 互斥，线型样式另置静态叠加路径——skills/06 清单第 3 条）。 */
+const ThreeCurves: React.FC = () => {
+  const frame = useCurrentFrame();
+  const axis = ci(frame, 0, 14);
+  const draw = ci(frame, 16, 46);
+  const hold = ci(frame, 60, 74);
+  const W = 1160;
+  const H = 420;
+  const x0 = 90;
+  const y0 = 350;
+  const span = W - x0 - 60;
+    // 三条路径（二次贝塞尔近似）：上扬 / 平台 / 震荡
+  const pathOf = (kind: 'compound' | 'saturate' | 'oscillate') => {
+    if (kind === 'compound') {
+      return `M ${x0} ${y0} Q ${x0 + span * 0.45} ${y0 - 60}, ${x0 + span * draw} ${y0 - 250 * draw - 20 * (1 - draw)}`;
+    }
+    if (kind === 'saturate') {
+      const end = x0 + span * draw;
+      return `M ${x0} ${y0} Q ${x0 + span * 0.3} ${y0 - 170}, ${end} ${y0 - 150 - 20 * (1 - draw)}`;
+    }
+    const seg = 8;
+    let d = `M ${x0} ${y0}`;
+    for (let k = 1; k <= seg; k++) {
+      const t = (k / seg) * draw;
+      const x = x0 + span * t;
+      const y = y0 - 90 * t - Math.sin(t * Math.PI * 6) * 62 * t;
+      d += ` L ${x.toFixed(1)} ${y.toFixed(1)}`;
+    }
+    return d;
+  };
+  return (
+    <AbsoluteFill style={{justifyContent: 'center', alignItems: 'center'}}>
+      <svg width={W} height={H}>
+        {/* 坐标轴 */}
+        <line x1={x0} y1={y0} x2={x0 + span * axis} y2={y0} stroke={theme.panelBorder} strokeWidth={2} />
+        <line x1={x0} y1={y0} x2={x0} y2={y0 - 300 * axis} stroke={theme.panelBorder} strokeWidth={2} />
+        <text x={x0 - 58} y={y0 - 292} fill={theme.dim} fontSize={19} fontFamily={theme.sans} opacity={axis}>
+          进步
+        </text>
+        {/* 右端轴标签用 text-anchor="end" 贴住轴末端，避免超出 svg 画布被截断 */}
+        <text
+          x={x0 + span}
+          y={y0 + 30}
+          textAnchor="end"
+          fill={theme.dim}
+          fontSize={19}
+          fontFamily={theme.sans}
+          opacity={axis}
         >
-          <div style={{display: 'flex', gap: 8, marginBottom: 18}}>
-            <span style={{width: 40, height: 8, borderRadius: 4, background: theme.exp}} />
-            <span style={{width: 40, height: 8, borderRadius: 4, background: theme.harness}} />
-            <span style={{width: 40, height: 8, borderRadius: 4, background: theme.params}} />
-          </div>
-          <div style={{fontFamily: theme.sans, fontSize: 30, fontWeight: 700, color: theme.text}}>
-            本期：上线之后，AI 才开始上学
-          </div>
-          <div style={{marginTop: 12, fontFamily: theme.sans, fontSize: 24, color: theme.dim, lineHeight: 1.6}}>
-            上了班之后，经验怎么攒？
-            <br />
-            ——「怎么攒」
-          </div>
-        </div>
+          反复自我改进
+        </text>
+        {/* 三条轨迹：线型区分（实线/虚线/点线），全金色 */}
+        <path d={pathOf('compound')} fill="none" stroke={theme.exp} strokeWidth={4.5} strokeLinecap="round" />
+        <path
+          d={pathOf('saturate')}
+          fill="none"
+          stroke={theme.exp}
+          strokeWidth={4.5}
+          strokeLinecap="round"
+          strokeDasharray="16 12"
+        />
+        <path d={pathOf('oscillate')} fill="none" stroke={theme.exp} strokeWidth={4.5} strokeDasharray="2 9" />
+        {/* 三个问号（衬线）随 hold 渐显 */}
+        {[
+          {x: x0 + span - 30, y: y0 - 262, o: hold},
+          {x: x0 + span - 30, y: y0 - 168, o: ci(frame, 64, 78)},
+          {x: x0 + span - 30, y: y0 - 40, o: ci(frame, 68, 82)},
+        ].map((p, i) => (
+          <text key={i} x={p.x} y={p.y} fill={theme.exp} fontSize={44} fontFamily={theme.serif} opacity={p.o}>
+            ?
+          </text>
+        ))}
+      </svg>
+      <div style={{marginTop: 6, fontFamily: theme.mono, fontSize: 17, color: theme.dim, opacity: hold}}>
+        not known to compound, saturate, or oscillate（§10）
       </div>
     </AbsoluteFill>
   );
 };
 
-/** 6-F：配套清单卡（v2 新增，p6-13a/b）——111 篇 × 9 章计数器 + 九章名胶囊环绕 */
+/** 6-F：配套清单卡（p6-13a/b）——331 篇 × 9 章计数器（数据文件口径，v3 更正）+ 九章名胶囊环绕 */
 const RepoCard: React.FC = () => {
   const frame = useCurrentFrame();
   const {fps} = useVideoConfig();
   const enter = spring({frame, fps, config: {damping: 200}});
-  const count = Math.round(111 * ci(frame, 6, 40));
-  const chapters = ['技能', '记忆', '环境', '工具', '参数', '元进化', '评测', '安全', '定义'];
+  // 331 = data/papers.json 实测条数（2026-08-19 取数；站点首页 111 为未水合占位，勿引用）
+  const count = Math.round(331 * ci(frame, 6, 40));
+  const chapters = ['引言', '工位', '技能', '记忆', '环境', '大脑', '元进化', '评测', '安全'];
   return (
     <AbsoluteFill style={{justifyContent: 'center', alignItems: 'center'}}>
       <div
@@ -431,6 +527,9 @@ const RepoCard: React.FC = () => {
           </span>
           <span style={{fontFamily: theme.sans, fontSize: 34, color: theme.dim}}>章</span>
         </div>
+        <div style={{marginTop: 22, fontFamily: theme.mono, fontSize: 17, color: theme.dim, opacity: ci(frame, 44, 56)}}>
+          数据取自配套站点 data/papers.json · 2026-08-19
+        </div>
         <div style={{marginTop: 26, display: 'flex', flexWrap: 'wrap', justifyContent: 'center', gap: 12}}>
           {chapters.map((c, i) => {
             const e = ci(frame, 30 + i * 5, 40 + i * 5);
@@ -549,12 +648,15 @@ export const P6Ending: React.FC<{scene: SceneRange}> = ({scene}) => {
       <Sequence {...w('p6-08', 'p6-10')} name="6-D 三块拼图">
         <ThreePuzzles />
       </Sequence>
-      <Sequence {...w('p6-11', 'p6-13')} name="6-E 系列呼应">
-        <SeriesEcho />
+      <Sequence {...w('p6-11', 'p6-13')} name="6-E 共同的地基">
+        <VerificationBedrock />
       </Sequence>
       <Sequence {...w('p6-13a', 'p6-13b')} name="6-F 配套清单卡">
         <RepoCard />
       </Sequence>
+      <Sequence {...w('p6-13c', 'p6-13d')} name="6-F2 三条曲线">
+        <ThreeCurves />
+      </Sequence>
       <Sequence {...w('p6-14', 'p6-15')} name="6-G 原文卡">
         <FinalCard endFrame={endFrame('p6-15')} />
       </Sequence>
diff --git a/media/experience-era-agents-video/video/src/timing.json b/media/experience-era-agents-video/video/src/timing.json
new file mode 100644
index 000000000..1090a53bf
--- /dev/null
+++ b/media/experience-era-agents-video/video/src/timing.json
@@ -0,0 +1,8 @@
+{
+  "fps": 30,
+  "sentenceGapSec": 0.32,
+  "sceneGapSec": 0.9,
+  "leadInSec": 0.6,
+  "tailSec": 2.0,
+  "sceneCrossFadeSec": 0.4
+}
diff --git a/media/experience-era-agents-video/video/src/timing.ts b/media/experience-era-agents-video/video/src/timing.ts
index 8bf6f2a54..6d2379ada 100644
--- a/media/experience-era-agents-video/video/src/timing.ts
+++ b/media/experience-era-agents-video/video/src/timing.ts
@@ -1,14 +1,19 @@
 import type {ManifestItem, SceneRange, TimedSentence} from './types';
+import constants from './timing.json';
 
-export const FPS = 30;
+/** 时序常量单一事实源：本目录 timing.json（qa_frames.py / captions.py 读同一文件，
+ *  双语言镜像由此消灭；本集要调节奏只改 timing.json，不动代码） */
+export const FPS = constants.fps;
 /** 句间停顿 */
-const SENTENCE_GAP_SEC = 0.32;
+const SENTENCE_GAP_SEC = constants.sentenceGapSec;
 /** 幕间额外停顿（转场呼吸） */
-const SCENE_GAP_SEC = 0.9;
+const SCENE_GAP_SEC = constants.sceneGapSec;
 /** 片头静默引导 */
-const LEAD_IN_SEC = 0.6;
+const LEAD_IN_SEC = constants.leadInSec;
 /** 片尾静默淡出 */
-const TAIL_SEC = 2.0;
+const TAIL_SEC = constants.tailSec;
+/** 幕间呼吸淡入淡出帧数（见 components/SceneFade.tsx；首幕不淡入、末幕不淡出） */
+export const SCENE_FADE_FRAMES = Math.round(constants.sceneCrossFadeSec * constants.fps);
 
 export function computeTimeline(manifest: ManifestItem[]): {
   timed: TimedSentence[];
diff --git a/media/pipeline/README.md b/media/pipeline/README.md
index d5676f3aa..ac0bc26c8 100644
--- a/media/pipeline/README.md
+++ b/media/pipeline/README.md
@@ -1,7 +1,7 @@
 # 科普视频制作 Pipeline（公共基建）
 
 > 从「论文精读 → 逐字稿 → 配音 → 代码动画 → 终渲」全链路中沉淀的**仓库级可复用流水线**。
-> 首个完整范例：[《AI 如何自己变强？》](../self-improving-agents-video/README.md)（Remotion 工程模式）；轻量替代：[video-package 制作包模式](../../video-package/README.md)。
+> 首个建成的完整范例：[《AI 如何自己变强？》](../self-improving-agents-video/README.md)（建成时间上的第一个，非系列首集；发布顺序见 [../series.json](../series.json)）。
 
 ## 一、Pipeline 总览（9 Stages）
 
@@ -49,7 +49,24 @@ media/<slug>-video/
 - narration.md：`## P0 标题` 分幕 + `- [p0-01] 文本` 一句一行；句 id 必须以幕名小写为前缀、全片唯一。
 - `>` 引用块为画面备注，不进配音；英文方法名做角标不口播。
 
-## 三、公共脚本（单一事实源）
+## 三、公共脚本（单一事实源）与编排入口
+
+**单入口 `pipeline.py`**（参数读各集 `pipeline.toml`；阶段契约见下表）：
+
+```
+uv run --no-project media/pipeline/scripts/pipeline.py --project media/<slug>-video     {status|doctor|build|check|tts|captions|render|qa|all|clean-samples}
+```
+
+| Stage | 命令 | 输入 → 产出 | 幂等/续跑 |
+|---|---|---|---|
+| ③ | `build` | narration.md → narration.json | 纯函数 |
+| ④⑤ | `check` | narration.json + storyboard.md + pipeline.toml → 门 | — |
+| ⑥ | `tts [--plan]` | narration.json + 参考样本 → 逐句 mp3 + manifest | sidecar 摘要 / 逐句续跑 |
+| ⑥+ | `captions` | manifest + timing.json → out/captions.{srt,vtt} | 纯函数 |
+| ⑧ | `render` + `qa` | src + audio → draft.mp4 + 抽帧体检 | 渲染否 / 抽帧是 |
+| ⑨ | `render --final` | 同上 → final.mp4（前置：⑧ 零 FAIL） | 否 |
+
+`status` 为派生式新鲜度表（无状态文件——幂等已由内容摘要提供，再存阶段状态即第二事实源）；`doctor` 自检配置/时序 SSOT/样本指纹/IndexTTS 服务。
 
 | 脚本                                                       | 用途                                                                                                                    | 工程内等价调用                                                                                                                                   |
 | ---------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
@@ -59,25 +76,32 @@ media/<slug>-video/
 | [scripts/tts_sample.py](./scripts/tts_sample.py)           | 单句声音小样试听（直调 IndexTTS 服务合成一句话 + 全风格 A/B，定稿风格前的必经关口）                                      | 无工程薄包装，从仓库根调用：`uv run --no-project --with mutagen media/pipeline/scripts/tts_sample.py --ref <样本.wav> --all-styles --play`，见 [VOICE-CLONING.md §5.1](./VOICE-CLONING.md) |
 | [scripts/prepare_ref.py](./scripts/prepare_ref.py)         | 参考音色样本裁剪/规范化（长录音 → 5–15s 干净 WAV）                                                                      | 无工程薄包装（与具体工程无关），从仓库根调用：`uv run --no-project --with soundfile --with numpy media/pipeline/scripts/prepare_ref.py <源音频>` |
 | [scripts/prospect_ref.py](./scripts/prospect_ref.py)       | 参考样本选段勘探（按 F0/起伏/音节率/谱质心筛「更亮更轻快」的候选起点，喂给 prepare_ref.py）                              | 无工程薄包装，从仓库根调用：`uv run --no-project --with soundfile --with numpy media/pipeline/scripts/prospect_ref.py <源音频…>`，见 [VOICE-CLONING.md §3.2](./VOICE-CLONING.md) |
-| [scripts/qa_frames.py](./scripts/qa_frames.py)             | 按句 id 抽帧视觉 QA                                                                                                     | `uv run --no-project scripts/qa_frames.py out/draft.mp4 --scene P2`                                                                              |
+| [scripts/pipeline.py](./scripts/pipeline.py)             | **单入口编排**（上表）                                                                                                  | `uv run --no-project media/pipeline/scripts/pipeline.py --project media/<工程> tts --plan`                                                      |
+| [scripts/timeline.py](./scripts/timeline.py)             | 时间轴 Python 侧实现（与 timing.ts 同构，直读 timing.json）                                                            | 被 qa_frames/captions/check_script 复用                                                                                                          |
+| [scripts/check_script.py](./scripts/check_script.py)     | ④⑤ 内容门：beat 覆盖性 / 时长预算双口径 / SceneFade 不变式 / `--check-scenes` 分镜↔代码互比                            | `uv run --no-project scripts/check_script.py --check-scenes`                                                                                   |
+| [scripts/check_series.py](./scripts/check_series.py)     | 系列一致性五规则（口播反串线 / 多标题顺序 / 序号绑定 / 清单完整性 / 死链），执法 [../series.json](../series.json)         | 仓库根：`uv run --no-project media/pipeline/scripts/check_series.py`（已挂 pre-commit）                                                          |
+| [scripts/captions.py](./scripts/captions.py)             | 导出 srt/vtt（cue 终点不含句间停顿——外挂字幕静默期不留字）                                                             | `uv run --no-project scripts/captions.py`                                                                                                        |
+| [scripts/qa_frames.py](./scripts/qa_frames.py)           | 抽帧 QA（幕/句/`--last-n` 末 N 句）+ `--check` 四项自动体检 + `--check-theme` WCAG 对比度                               | `uv run --no-project --with pillow --with numpy scripts/qa_frames.py out/draft.mp4 --last-n 6 --check`（工程根；视频路径按 CWD 解析，仓库根调用写全 `media/<工程>/out/draft.mp4`）                                          |
+| [scripts/paper_extract.py](./scripts/paper_extract.py)   | Stage ① 取证工具箱（§→页映射 / 分栏取文 / caption 收割 / 定点 find / 页面光栅化）                                       | `uv run --no-project --with pymupdf media/pipeline/scripts/paper_extract.py "<PDF>" find "原文措辞"`                                             |
+| [scripts/refs.py](./scripts/refs.py)                     | 参考样本可复现清单（verify/rebuild；指纹在 [voices/refs.toml](./voices/refs.toml)，只存哈希不存音频）                    | `uv run --no-project media/pipeline/scripts/refs.py verify`                                                                                     |
 
 中心脚本以 `--project <工程根>` 参数化；工程内 `scripts/*.py` 为薄包装（透传参数、保持原 CLI）。改造/迭代只改 `media/pipeline/scripts/`，验证门 = 受影响工程的 `narration.json` / `manifest.json` 字节级不变。
 
 ## 四、复用边界（显式权衡）
 
 - **Python 脚本：集中共享（SSOT）**——三个纯文本变换工具，跨集零差异，中心化防 split-brain。
-- **Remotion 工程原语：复制适配，不做共享包**——`timing.ts` / `Subtitle` / `cards.tsx` / `theme.ts` 等每集复制后按本集视觉契约修改。理由：每集工程须保持 pnpm `--ignore-workspace` 独立可渲染（嵌套 workspace 隔离 + Remotion 版本自由），共享 TS 包会把「一集的视觉改动」泄漏进其他集。复用时以首集工程为模板复制 `video/` 骨架。
+- **Remotion 工程原语：复制适配，不做共享包**——`timing.ts` / `Subtitle` / `cards.tsx` / `theme.ts` 等每集复制后按本集视觉契约修改。理由：每集工程须保持 pnpm `--ignore-workspace` 独立可渲染（嵌套 workspace 隔离 + Remotion 版本自由），共享 TS 包会把「一集的视觉改动」泄漏进其他集。复用时以任一既有集工程为模板复制 `video/` 骨架（发布顺序见 [../series.json](../series.json)，与模板选择无关）。
 - **每集视觉契约独立设计**（色彩语义映射到本集核心概念），但底层规范复用：深色底 `#0E1116` 系、警示红 `#FF5C5C`、确认绿 `#7ED321`、金句卡衬线体、公式只作角标彩蛋。
 
 ## 五、音画同步机制（零手工对轨）
 
-每句一段 MP3；`tts.py` 产出 `video/public/audio/manifest.json`（含每句实测时长）；Remotion `calculateMetadata` 读取 manifest 计算全片时间轴（默认句间 0.32s、幕间 +0.9s、片头 0.6s、片尾 2s）。**改稿后只需重跑：build → tts → render**。引擎可选 edge 预置音色（默认）或用自己的声音克隆（[VOICE-CLONING.md](./VOICE-CLONING.md)），两种引擎的 manifest 契约完全一致。
+每句一段 MP3；`tts.py` 产出 `video/public/audio/manifest.json`（含每句实测时长）；Remotion `calculateMetadata` 读取 manifest 计算全片时间轴。**改稿后只需重跑：build → tts → render**。引擎可选 edge 预置音色（默认）或用自己的声音克隆（[VOICE-CLONING.md](./VOICE-CLONING.md)），两种引擎的 manifest 契约完全一致。
 
-⚠️ 若工程自定义了 `timing.ts` 常量，须同步 `qa_frames.py` 顶部的镜像常量，否则抽帧时间错位。
+**时序常数单一事实源** = 每集 `video/src/timing.json`（句间/幕间/片头/片尾/幕间淡入淡出）：`timing.ts` 经 `resolveJsonModule` 同步 import，Python 侧（qa_frames/captions/check_script）经 `timeline.py` 直读同一文件——改节奏只动 JSON，双语言镜像漂移结构性不存在。**渲染主机约束**：三集未内嵌 CJK 字体（PingFang SC/Songti SC/SF Mono 系统栈），渲染仅限 macOS；两个重启触发器见 [skills/06 事实条](./skills/06-remotion-implementation.md)。
 
 ## 六、新集脚手架清单
 
-1. `cp -r` 上一集工程目录骨架（README/research/script/scripts/video），改 slug 与内容。
+1. `cp -r` 任一既有集工程目录骨架（README/research/script/scripts/video/pipeline.toml），改 slug 与内容。
 2. `video/package.json` 改 `name`；清空 scenes 重建；`theme.ts` 换本集色板。
 3. 根 `.gitignore` 追加本集产物规则（**不能放工程内**——根级裸 `.gitignore` 规则会挡住嵌套 ignore 文件）：
    ```
@@ -92,13 +116,7 @@ media/<slug>-video/
 
 ## 七、工程模式
 
-|      | ✅ Remotion 工程模式                                               | ❌ 轻量制作包模式                                            |
-| ---- | ----------------------------------------------------------------- | ----------------------------------------------------------- |
-| 载体 | `media/<slug>-video/video/`（Remotion + React）                   | `video-package/`（单文件 Canvas HTML）                      |
-| 动画 | 全代码动画，可编程复渲                                            | 浏览器手动录屏                                              |
-| 配音 | edge-tts + manifest 自动对轨                                      | 人工录音/剪辑对齐                                           |
-| 适用 | 中长视频、多轮迭代、可复现                                        | 快速产出、低工程成本                                        |
-| 范例 | [《AI 如何自己变强？》](../self-improving-agents-video/README.md) | [《当 AI 开始给自己当老师》](../../video-package/README.md) |
+本仓统一采用 **Remotion 工程模式**（全代码动画 + manifest 自动对轨、可编程复渲）。早期的单文件 Canvas 轻量制作包模式已于 2026-08 废弃移除（见 commit `f7d72814`）。
 
 ## 八、许可注意
 
diff --git a/media/pipeline/VOICE-CLONING.md b/media/pipeline/VOICE-CLONING.md
index 4d92dfb15..35890b470 100644
--- a/media/pipeline/VOICE-CLONING.md
+++ b/media/pipeline/VOICE-CLONING.md
@@ -184,7 +184,7 @@ uv run --no-project --with soundfile --with numpy media/pipeline/scripts/prospec
 
 ### 4.3b 束搜索宽度（--num-beams，速度主旋钮）
 
-GPT 声码段的束搜索宽度，**缺省随风格**（多数预设 1、`sunny-steady` 为 3；上游库内部默认 3）。采样生成（`do_sample=True`）下 1 与 3 的听感差异可忽略，但 GPT 段耗时约按束宽线性放大。**MPS fp32 实测**（2026-08-18，M3 系列）：每句墙钟 = GPT 束搜索 + 扩散声码 + BigVGAN，RTF（耗时/音频时长）约 40–58（beams=3）；beams=1 下三集全量连续跑（596 句 / 40.2 分钟纯语音 / 8.5 小时墙钟）折算整集 RTF≈12–14；整集（约 180–230 句）约 2.5–3.5 小时，按句缓存可断点续跑。**束宽也是韵律稳定度旋钮**，不只是速度旋钮：3 束把语调起伏收窄约 10–20%，听感更"稳/可信"（见 §4.1）。三种用法按代价递增：单句重合成 `--num-beams 3`、关键句混合档 `--steady`（§5.2.1，推荐）、整集升档 `--style sunny-steady`。
+GPT 声码段的束搜索宽度，**缺省随风格**（多数预设 1、`sunny-steady` 为 3；上游库内部默认 3）。采样生成（`do_sample=True`）下 1 与 3 的听感差异可忽略，但 GPT 段耗时约按束宽线性放大。**MPS fp32 实测**（2026-08-18，M3 系列；⚠️ 该轮数据采集于机器有其它负载时——2026-08-20 空闲复测整集 RTF≈9.2，见 §4.3b）：每句墙钟 = GPT 束搜索 + 扩散声码 + BigVGAN，RTF（耗时/音频时长）约 40–58（beams=3，忙时口径）；beams=1 下三集全量连续跑（596 句 / 40.2 分钟纯语音 / 8.5 小时墙钟）折算整集 RTF≈12–14；整集（约 180–230 句）约 2.5–3.5 小时，按句缓存可断点续跑。**束宽也是韵律稳定度旋钮**，不只是速度旋钮：3 束把语调起伏收窄约 10–20%，听感更"稳/可信"（见 §4.1）。三种用法按代价递增：单句重合成 `--num-beams 3`、关键句混合档 `--steady`（§5.2.1，推荐）、整集升档 `--style sunny-steady`。
 
 **短句最贵、数字句更贵**（2026-08-19 实测，单句空闲口径）：RTF 随句长下降——4–6 秒的短句 3 束 RTF 19.6–31.5、1 束 6.0–7.4；13–15 秒长句 3 束仅 8.9–13.8。固定开销（条件提取、25 步扩散、BigVGAN）被长音频摊薄了。数字密集句最贵（`2026 年 6 月…88 页` 一句 5.87 秒音频烧了 185 秒，RTF 31.5），因为数字会被文本归一展开成口语形式、token 数暴涨。**逐字稿为字幕可读性把句子都拆到 ≤43 字，正好落在最贵区间**，排期请按短句口径留余量。
 
@@ -199,7 +199,7 @@ GPT 声码段的束搜索宽度，**缺省随风格**（多数预设 1、`sunny-
 
 5. **最后定束宽**：想让语气更"稳/可信"就上 3 束（`--style sunny-steady`），代价是整集墙钟 ×2–5；赶工或改稿频繁期用 1 束的 `sunny`。
 
-**推荐位**：日常/批量用 **`sunny`（明快阳光）**，成片定稿用 **`sunny-steady`（明快稳健）**——两档参数完全相同、只差束宽，故可"先用 sunny 快速迭代文稿，定稿再用 sunny-steady 重跑一遍"（换档会改摘要 → 全量重合成，须留出时间）。两档都配 `voices/me-bright.wav`。历史上曾推荐 `passionate`，但其有效注入 0.70 在本人样本上偏"用力"，已改为 sunny 系。**任何情况下都先跑小样确认，再全量合成。**
+**推荐位**：日常/批量用 **`sunny`（明快阳光）**，成片定稿用 **`sunny-steady`（明快稳健）**——两档参数完全相同、只差束宽，故可"先用 sunny 快速迭代文稿，定稿再用 sunny-steady 重跑一遍"（换档会改摘要 → 全量重合成；机器空闲时两遍合计约 4 小时、并非数量级负担，见 §4.3b 复测）。两档都配 `voices/me-bright.wav`。历史上曾推荐 `passionate`，但其有效注入 0.70 在本人样本上偏"用力"，已改为 sunny 系。**任何情况下都先跑小样确认，再全量合成。**
 
 ## 五、小样试听与逐集合成
 
@@ -315,7 +315,7 @@ uv run --no-project --with mutagen scripts/tts.py --engine indextts \
 
 #### 5.2.1 混合档：整集 1 束 + 关键句 3 束（`--steady`）
 
-3 束（`sunny-steady`）韵律更稳但整集要 9.9 小时，而真正决定第一印象的只是冷开场与各幕金句。`--steady` 让这些句子单独升档，其余仍按风格的束宽跑：
+3 束（`sunny-steady`）韵律更稳。机器空闲时整集升档实测仅 +4%（见 §4.3b 复测），可直接整集跑；**机器忙/热节流时**整集升档代价可达数倍，而真正决定第一印象的只是冷开场与各幕金句——`--steady` 让这些句子单独升档，其余仍按风格的束宽跑：
 
 ```bash
 uv run --no-project --with mutagen scripts/tts.py --engine indextts \
@@ -340,7 +340,14 @@ uv run --no-project --with mutagen scripts/tts.py --engine indextts \
 | `--style sunny --steady 'P0,p3-25b,p5-01'` | 20 | 3.6 h | +24% |
 | `--style sunny-steady`（整集升档） | 189 | **9.9 h** | +241% |
 
-即**每升 1 句约 +2.2 分钟（+1.3%）**——升十几句买到关键处的稳定度是划算的，整集升档则不划算。缓存 sidecar 按句独立（摘要含 `|beams=N`），故混用两种束宽完全安全，也可以先全集跑 `sunny`、事后再补 `--steady 'P0'` 只重合成那几句。
+即**每升 1 句约 +2.2 分钟（+1.3%）**——升十几句买到关键处的稳定度是划算的，整集升档则不划算。
+
+> ⚠️ **2026-08-20 复测推翻了「整集升档不划算」这一结论的前提**（EP1 v3 两遍法，187 句，机器空闲）：
+> A 遍 `sunny`(beams=1) 墙钟 ≈1.9 h、B 遍 `sunny-steady`(beams=3) 墙钟 **1.98 h**——**B/A ≈ 1.04，而非 +241%**。
+> 实测 RTF：1 束 ≈8.8、3 束 ≈9.2（`--plan` 常量分别为 13 / 45，即 3 束估算偏保守约 4.9 倍）。
+> 上表的 9.9 h 数据应是在机器被占用或热节流时测得。**新口径：机器空闲时整集直上 `sunny-steady` 是可行的**
+> （本集即如此完成），`--steady` 混合档的价值退回到「机器忙时的折中手段」。`--plan` 常量刻意不下调——
+> 排期宁可高估留窗口，但看到估算与实测差 3–5 倍属正常。缓存 sidecar 按句独立（摘要含 `|beams=N`），故混用两种束宽完全安全，也可以先全集跑 `sunny`、事后再补 `--steady 'P0'` 只重合成那几句。
 
 - 服务启动一次可服务多集；管线客户端不常驻模型；
 - 每句墙钟与文本长度及束宽相关：长跑折算 RTF≈45（3 束）/ ≈13（1 束）。**1 束整集（约 180–230 句）约 2.5–3.5 小时；3 束整集约 9–10 小时**（`--plan` 会按这两个口径给出估算）——请据此选档并 `nohup` 挂后台跑，按句缓存可断点续跑（见 §六）；
diff --git a/media/pipeline/scripts/build_narration.py b/media/pipeline/scripts/build_narration.py
index 36845d2c4..cdee5ca24 100644
--- a/media/pipeline/scripts/build_narration.py
+++ b/media/pipeline/scripts/build_narration.py
@@ -13,10 +13,12 @@
 import argparse
 import json
 import re
+import sys
 from pathlib import Path
 
 LINE_RE = re.compile(r"^- \[(?P<id>[a-z0-9-]+)\]\s+(?P<text>.+)$")
 SCENE_RE = re.compile(r"^## (?P<scene>P\d+)\b")
+FORMAT_DOC = "media/pipeline/README.md 第二节格式契约"
 
 
 def main() -> None:
@@ -28,19 +30,32 @@ def main() -> None:
     src = root / "script" / "narration.md"
     dst = root / "script" / "narration.json"
 
+    # 与 tts.py 同口径的可操作退出（而非裸 FileNotFoundError 栈）
+    if not src.is_file():
+        sys.exit(f"narration.md 不存在: {src} —— 见 {FORMAT_DOC}")
+
     scene = ""
     items: list[dict[str, str]] = []
     seen: set[str] = set()
-    for raw in src.read_text(encoding="utf-8").splitlines():
+    for lineno, raw in enumerate(src.read_text(encoding="utf-8").splitlines(), 1):
         if m := SCENE_RE.match(raw):
             scene = m.group("scene")
             continue
         if m := LINE_RE.match(raw):
             sid, text = m.group("id"), m.group("text").strip()
+            if not scene:
+                # 幕名为空时下一条校验会报出「与所在幕  不一致」这种令人困惑的信息，
+                # 故先明确指出真正的原因：首句之前缺 `## Pn` 标题。
+                sys.exit(
+                    f"{src}:{lineno} 句 {sid} 出现在任何 `## Pn` 分幕标题之前 —— 每句必须归属于某一幕，见 {FORMAT_DOC}"
+                )
             if sid in seen:
-                raise SystemExit(f"重复句 id: {sid}")
+                sys.exit(f"{src}:{lineno} 重复句 id: {sid}")
             if not sid.startswith(scene.lower() + "-"):
-                raise SystemExit(f"句 id {sid} 与所在幕 {scene} 不一致")
+                sys.exit(
+                    f"{src}:{lineno} 句 id {sid} 与所在幕 {scene} 不一致 —— "
+                    f"句 id 必须以幕名小写为前缀（应为 {scene.lower()}-…）"
+                )
             seen.add(sid)
             items.append({"id": sid, "scene": scene, "text": text})
 
diff --git a/media/pipeline/scripts/captions.py b/media/pipeline/scripts/captions.py
new file mode 100644
index 000000000..cb7d03d21
--- /dev/null
+++ b/media/pipeline/scripts/captions.py
@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+"""从 manifest + timing.json 导出外挂字幕（.srt / .vtt）——B 站/YouTube 上传件。
+
+时间已精确已知（每句实测 durationSec + 时间轴常数），导出是纯白捡的交付物。
+与 Subtitle.tsx（片内烧录字幕）有一个**有意分歧**：烧录字幕保留整句时间窗
+（含句间停顿，便于阅读）；外挂字幕的 cue 终点 = 起点 + durationSec——静默期
+不该留字，否则平台播放器里上一句会挂到下一句开口。
+
+用法：uv run --no-project media/pipeline/scripts/captions.py --project media/<工程> \
+          [--format srt,vtt] [--out out]
+输出：<工程>/out/captions.srt 与 .vtt（out/ 已 gitignore）
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))  # noqa: E402
+from timeline import compute, load_constants  # noqa: E402
+
+
+def fmt_ts_srt(sec: float) -> str:
+    ms = round(sec * 1000)
+    h, ms = divmod(ms, 3600_000)
+    m, ms = divmod(ms, 60_000)
+    s, ms = divmod(ms, 1000)
+    return f"{h:02d}:{m:02d}:{s:02d},{ms:03d}"
+
+
+def fmt_ts_vtt(sec: float) -> str:
+    return fmt_ts_srt(sec).replace(",", ".")
+
+
+def build_cues(items: list[dict], c: dict) -> list[tuple[float, float, str]]:
+    """[(startSec, endSec, text)]；end = start + durationSec（不含停顿，见模块注释）。"""
+    return [
+        (r["startSec"], r["startSec"] + r["durationSec"], r["text"])
+        for r in compute(items, c)
+    ]
+
+
+def render_srt(cues: list[tuple[float, float, str]]) -> str:
+    out = []
+    for i, (a, b, text) in enumerate(cues, 1):
+        out.append(f"{i}\n{fmt_ts_srt(a)} --> {fmt_ts_srt(b)}\n{text}\n")
+    return "\n".join(out)
+
+
+def render_vtt(cues: list[tuple[float, float, str]]) -> str:
+    body = "\n".join(
+        f"{fmt_ts_vtt(a)} --> {fmt_ts_vtt(b)}\n{text}\n" for a, b, text in cues
+    )
+    return f"WEBVTT\n\n{body}"
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description="导出 srt/vtt 外挂字幕")
+    ap.add_argument("--project", default=".", help="视频工程根目录")
+    ap.add_argument("--format", default="srt,vtt", help="逗号分隔（默认 srt,vtt）")
+    ap.add_argument("--out", default=None, help="输出目录（默认 <工程>/out）")
+    args = ap.parse_args()
+
+    root = Path(args.project).resolve()
+    manifest = root / "video" / "public" / "audio" / "manifest.json"
+    if not manifest.is_file():
+        sys.exit(f"manifest.json 不存在: {manifest} —— 先运行 scripts/tts.py 合成配音")
+    items = json.loads(manifest.read_text(encoding="utf-8"))
+    c = load_constants(root)
+    cues = build_cues(items, c)
+    out_dir = Path(args.out).resolve() if args.out else root / "out"
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    for fmt in args.format.split(","):
+        fmt = fmt.strip().lower()
+        renderer = {"srt": render_srt, "vtt": render_vtt}.get(fmt)
+        if renderer is None:
+            ap.error(f"不支持的字幕格式: {fmt}（可选 srt / vtt）")
+        dest = out_dir / f"captions.{fmt}"
+        dest.write_text(renderer(cues), encoding="utf-8")
+        print(f"{len(cues)} cues -> {dest}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/media/pipeline/scripts/check_script.py b/media/pipeline/scripts/check_script.py
new file mode 100644
index 000000000..68719bde7
--- /dev/null
+++ b/media/pipeline/scripts/check_script.py
@@ -0,0 +1,216 @@
+#!/usr/bin/env python3
+"""④⑤ 内容门：分镜覆盖性、时长预算、淡入不变式——公共管线版本。
+
+机械化三件此前靠人眼/散文守着的事：
+  1. storyboard 的 beat 句 id 区间必须**覆盖**本幕每一句（无缺句），重叠仅允许
+     「标题卡/章头压前句尾」的刻意惯例（该 beat 的句区间单元格以「尾」结尾标注）；
+  2. 时长预算：narration.json 字数估算与 manifest 实测（若已合成）两个口径都对
+     pipeline.toml 的 target_minutes 负责——首次把「策划宣称/估算/实测」三处接上；
+  3. 幕间呼吸淡入淡出的不变式：2×sceneCrossFadeSec ≤ sentenceGap+sceneGap
+    （淡入淡出必须花在既有静默里，时间轴零位移的前提）。
+
+可选 --check-scenes：从 video/src/scenes/*.tsx 提取 beatWindow/w('id','id')
+调用，与分镜表互比（WARN-only，TSX 正则本质近似）。
+
+用法：uv run --no-project media/pipeline/scripts/check_script.py --project media/<工程>
+退出码：0 = 通过；1 = 有 FAIL。WARN 不影响退出码但会列明。
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+import tomllib
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))  # noqa: E402
+from timeline import load_constants, total_duration_in_frames  # noqa: E402
+
+#: 分镜表行：| 镜号 | 句区间 | 画面 | 动效 |。镜号形如 `0-A`/`2-B2`，句区间形如
+#: `p0-01..03`（右端可为裸编号，须补幕前缀）、`p6-06a..06d`、单句 `p6-07`。
+BEAT_ROW_RE = re.compile(
+    r"^\|\s*(\d+-[A-Z]\d*)[^|]*\|\s*(p\d+-[0-9a-z-]+(?:\.\.[0-9a-z-]+)?)\s*([^|]*)\|"
+)
+#: 场景组件里的 beat 调用。实际形如 `w('p0-01', 'p0-04')`（各场景统一先定义
+#: `const w = (fromId, toId?) => beatWindow(scene.sentences, scene.from, …)` 再使用），
+#: 故匹配任意 `\w(...)` 调用并要求参数为 1–2 个单引号句 id。
+SCENE_CALL_RE = re.compile(r"\bw\(\s*'([a-z0-9-]+)'(?:\s*,\s*'([a-z0-9-]+)')?\s*\)")
+#: 幕名（P0/P1/…）从句 id 前缀还原
+SCENE_OF_RE = re.compile(r"^(p\d+)-")
+
+
+def fail(msgs: list[str], text: str) -> None:
+    msgs.append(f"FAIL {text}")
+
+
+def warn(msgs: list[str], text: str) -> None:
+    msgs.append(f"WARN {text}")
+
+
+def parse_storyboard(path: Path) -> list[tuple[str, str, str, str]]:
+    """返回 [(镜号, 起句id, 止句id, 区间单元格原文)]。单元格原文含「尾」= 刻意压尾标注。"""
+    beats: list[tuple[str, str, str, str]] = []
+    for raw in path.read_text(encoding="utf-8").splitlines():
+        if m := BEAT_ROW_RE.match(raw):
+            beat_id, span, cell = m.group(1), m.group(2), (m.group(2) + m.group(3))
+            if ".." in span:
+                left, _, right = span.partition("..")
+                # 右端可为裸编号（p0-01..03）——须补幕前缀，否则永远匹配不到句子
+                if not right.startswith("p"):
+                    scene = SCENE_OF_RE.match(left).group(1)  # type: ignore[union-attr]
+                    right = f"{scene}-{right}"
+            else:
+                left = right = span
+            beats.append((beat_id, left, right, cell))
+    return beats
+
+
+def check_coverage(
+    items: list[dict], beats: list[tuple[str, str, str, str]], msgs: list[str]
+) -> None:
+    ids = [i["id"] for i in items]
+    pos = {sid: k for k, sid in enumerate(ids)}
+    covered = [False] * len(ids)
+    for beat_id, left, right, cell in beats:
+        if left not in pos or right not in pos:
+            bad = left if left not in pos else right
+            fail(
+                msgs,
+                f"镜 {beat_id}：句 id {bad!r} 不在 narration.json（分镜陈旧或笔误）",
+            )
+            continue
+        a, b = pos[left], pos[right]
+        if b < a:
+            fail(msgs, f"镜 {beat_id}：区间 {cell} 起止倒置")
+            continue
+        overlap = any(covered[a : b + 1])
+        deliberate = "尾" in cell  # 区间单元格原文含「尾」= 标题卡压前句尾的刻意惯例
+        for k in range(a, b + 1):
+            covered[k] = True
+        if overlap and not deliberate:
+            warn(
+                msgs,
+                f"镜 {beat_id}：区间 {cell} 与前镜重叠（若为标题卡压前句尾的刻意设计，请在句区间后标注「尾」）",
+            )
+    missing = [sid for sid, c in zip(ids, covered, strict=False) if not c]
+    if missing:
+        fail(msgs, f"分镜未覆盖 {len(missing)} 句: {' '.join(missing)}")
+    # 分镜表与代码的镜号互比（按幕：分镜镜号前缀数字 == 幕序号）
+    scene_nums = sorted({int(SCENE_OF_RE.match(i["id"]).group(1)[1:]) for i in items})  # type: ignore[union-attr]
+    beat_nums = sorted({int(b[0].split("-")[0]) for b in beats})
+    if beat_nums and beat_nums != scene_nums:
+        warn(msgs, f"分镜覆盖的幕 {beat_nums} 与 narration 的幕 {scene_nums} 不一致")
+
+
+def check_budget(root: Path, items: list[dict], cfg: dict, msgs: list[str]) -> None:
+    narr = cfg.get("narration", {})
+    lo, hi = narr.get("target_minutes", [0, 999])
+    cpm = narr.get("chars_per_min", 280)
+    chars = sum(len(i["text"]) for i in items)
+    est_min = chars / cpm
+    print(
+        f"  估算口径：{chars} 字 ÷ {cpm} 字/分 = {est_min:.1f} 分钟（目标 {lo}–{hi}）"
+    )
+    if not lo <= est_min <= hi:
+        fail(msgs, f"估算时长 {est_min:.1f} 分超预算 [{lo}, {hi}]")
+    manifest = root / "video" / "public" / "audio" / "manifest.json"
+    if manifest.is_file():
+        c = load_constants(root)
+        m_items = json.loads(manifest.read_text(encoding="utf-8"))
+        real_min = total_duration_in_frames(m_items, c) / c["fps"] / 60
+        print(
+            f"  实测口径：manifest {len(m_items)} 句，含时距总长 = {real_min:.1f} 分钟"
+        )
+        if not lo <= real_min <= hi:
+            fail(msgs, f"实测时长 {real_min:.1f} 分超预算 [{lo}, {hi}]")
+        if {i["id"] for i in m_items} != {i["id"] for i in items}:
+            fail(msgs, "manifest 与 narration.json 的句 id 集不一致——改稿后未重跑 tts")
+    else:
+        print("  实测口径：manifest 未生成（跳过；合成后复跑本门）")
+
+
+def check_fade_invariant(root: Path, msgs: list[str]) -> None:
+    c = load_constants(root)
+    budget = c["sentenceGapSec"] + c["sceneGapSec"]
+    if 2 * c["sceneCrossFadeSec"] > budget:
+        fail(
+            msgs,
+            f"2×sceneCrossFadeSec({c['sceneCrossFadeSec']}) > 幕间静默预算({budget:.2f}s)"
+            " —— 淡入淡出会吃进句子音频，SceneFade 时间轴零位移前提被破坏",
+        )
+
+
+def check_scenes(
+    root: Path, beats: list[tuple[str, str, str, str]], msgs: list[str]
+) -> None:
+    scenes_dir = root / "video" / "src" / "scenes"
+    if not scenes_dir.is_dir():
+        return
+    code_pairs: set[tuple[str, str]] = set()
+    for tsx in sorted(scenes_dir.glob("*.tsx")):
+        for m in SCENE_CALL_RE.finditer(tsx.read_text(encoding="utf-8")):
+            left, right = m.group(1), m.group(2) or m.group(1)
+            code_pairs.add((left, right))
+    board_pairs = {(left, right) for _, left, right, _ in beats}
+    for pair in sorted(board_pairs - code_pairs):
+        warn(
+            msgs,
+            f"分镜区间 {pair[0]}..{pair[1]} 未在场景代码中找到对应 beatWindow/w 调用",
+        )
+    for pair in sorted(code_pairs - board_pairs):
+        warn(msgs, f"场景代码区间 {pair[0]}..{pair[1]} 未在分镜表中登记（分镜陈旧）")
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description="④⑤ 内容门：覆盖性/预算/淡入不变式")
+    ap.add_argument("--project", default=".", help="视频工程根目录")
+    ap.add_argument(
+        "--check-scenes",
+        action="store_true",
+        help="附:分镜↔场景代码 beat 互比（WARN-only）",
+    )
+    ap.add_argument(
+        "--json", action="store_true", help="以 JSON 输出结果（供 pipeline.py 汇总）"
+    )
+    args = ap.parse_args()
+
+    root = Path(args.project).resolve()
+    cfg_path = root / "pipeline.toml"
+    cfg = (
+        tomllib.loads(cfg_path.read_text(encoding="utf-8"))
+        if cfg_path.is_file()
+        else {}
+    )
+    items = json.loads((root / "script" / "narration.json").read_text(encoding="utf-8"))
+    board = root / "script" / "storyboard.md"
+    if not board.is_file():
+        sys.exit(f"storyboard.md 不存在: {board}")
+
+    msgs: list[str] = []
+    beats = parse_storyboard(board)
+    if not beats:
+        fail(msgs, f"未能从 {board.name} 解析出任何 beat 行（格式变化？）")
+    check_coverage(items, beats, msgs)
+    check_budget(root, items, cfg, msgs)
+    check_fade_invariant(root, msgs)
+    if args.check_scenes:
+        check_scenes(root, beats, msgs)
+
+    fails = [m for m in msgs if m.startswith("FAIL")]
+    warns = [m for m in msgs if m.startswith("WARN")]
+    if args.json:
+        print(
+            json.dumps({"fails": fails, "warns": warns}, ensure_ascii=False, indent=1)
+        )
+    else:
+        print(f">> 内容门 · {root.name} · {len(items)} 句 / {len(beats)} 镜")
+        for m in msgs:
+            print(f"  {m}")
+        print(f">> FAIL {len(fails)} · WARN {len(warns)}")
+    sys.exit(1 if fails else 0)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/media/pipeline/scripts/check_series.py b/media/pipeline/scripts/check_series.py
new file mode 100644
index 000000000..2e76c5115
--- /dev/null
+++ b/media/pipeline/scripts/check_series.py
@@ -0,0 +1,231 @@
+#!/usr/bin/env python3
+"""系列一致性校验——media/series.json（发布顺序 SSOT）的机械化执法。
+
+此前顺序只活在散文与 React 常量里（EP3 的 SeriesThree 数组说「第一集=AI 如何
+自己变强」而意图已变），且反串线 lint 无法只用 grep 实现：EP1 的 p1-25a 会命中
+自己的片名「上线之后」——正确排除自身标题必须知道标题属于哪个工程，也就是
+必须有清单。本脚本按价值降序执行五条规则：
+
+  1. 口播反串线：任一集 narration.md 的口播行出现**他集标题**或顺序词
+     （上一集/上期/第N集/前两集/本系列…）即 FAIL；自身标题排除；「下期」白名单
+     （顺序无关收尾语）
+  2. 多标题顺序：同一文件出现 ≥2 集标题时，首现顺序必须等于清单 episode 顺序
+     —— 一条规则覆盖 SeriesThree 数组、storyboard、README、planning、知识索引
+  3. 序号↔标题绑定：`第N集` 附近的标题必须与该集 episode 匹配
+  4. 清单完整性：episode 连续无重、slug 唯一、路径存在、accents 色值在该集
+     theme.ts 中存在
+  5. 相对链接死链：受检文件集内的 `](./x.md)` / `](../x)` 目标必须存在
+    （抓 video-package 类残留并防复发）
+
+用法：uv run --no-project media/pipeline/scripts/check_series.py
+退出码：0 = 一致；1 = 有 FAIL。挂牌 pre-commit 后自动覆盖 media/ 相关提交。
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import sys
+from pathlib import Path
+
+REPO = Path(__file__).resolve().parents[3]
+SERIES_JSON = REPO / "media" / "series.json"
+
+#: 顺序词。白名单：「下期」顺序无关收尾语；「前两集」从终集视角恒真（相对表述，改序仍成立）
+ORDINAL_WORDS = re.compile(
+    r"上一集|上集|上期|下一集|下集|第[一二三四五六七八九十]集|前一集|本系列"
+)
+SPOKEN_LINE_RE = re.compile(r"^- \[(?P<id>[a-z0-9-]+)\]\s+(?P<text>.+)$", re.M)
+REL_LINK_RE = re.compile(r"\]\((\.{1,2}/[^)#?]+)\)")
+EP_NUM = re.compile(r"第([一二三四五六七八九十])集")
+
+CN_NUM = {
+    "一": 1,
+    "二": 2,
+    "三": 3,
+    "四": 4,
+    "五": 5,
+    "六": 6,
+    "七": 7,
+    "八": 8,
+    "九": 9,
+    "十": 10,
+}
+
+#: 受检文件集（规则 2/3/5 的扫描范围；.context 等工作区目录不含）
+COVERED_GLOBS = (
+    "media/**/*.md",
+    "media/**/*.tsx",
+    "media/**/*.ts",
+    "docs/.agents/knowledge-map.md",
+    "CHANGELOG.md",
+)
+
+
+def load_series() -> dict:
+    if not SERIES_JSON.is_file():
+        sys.exit(f"series.json 不存在: {SERIES_JSON}")
+    data = json.loads(SERIES_JSON.read_text(encoding="utf-8"))
+    eps = data.get("episodes", [])
+    if not eps:
+        sys.exit("series.json 无 episodes")
+    return data
+
+
+def covered_files() -> list[Path]:
+    out: list[Path] = []
+    for g in COVERED_GLOBS:
+        out.extend(
+            p for p in REPO.glob(g) if p.is_file() and "node_modules" not in p.parts
+        )
+    return sorted(set(out))
+
+
+def rule_spoken_interleave(series: dict, msgs: list[str]) -> None:
+    """规则 1：口播反串线。"""
+    for ep in series["episodes"]:
+        others = [e["title"] for e in series["episodes"] if e["slug"] != ep["slug"]]
+        narration = REPO / ep["path"] / "script" / "narration.md"
+        if not narration.is_file():
+            msgs.append(f"FAIL 规则1：{ep['slug']} 缺 {narration.relative_to(REPO)}")
+            continue
+        for m in SPOKEN_LINE_RE.finditer(narration.read_text(encoding="utf-8")):
+            sid, text = m.group("id"), m.group("text")
+            hit_other = [t for t in others if t in text]
+            if hit_other:
+                msgs.append(
+                    f"FAIL 规则1：{ep['slug']} {sid} 口播出现他集标题「{hit_other[0]}」"
+                )
+            if w := ORDINAL_WORDS.search(text):
+                msgs.append(
+                    f"FAIL 规则1：{ep['slug']} {sid} 口播出现顺序词「{w.group(0)}」"
+                    "——序号只允许存在于视觉层与 series.json"
+                )
+
+
+def rule_title_order(series: dict, files: list[Path], msgs: list[str]) -> None:
+    """规则 2：同一文件内多集标题的首现顺序 == 清单顺序。
+
+    文件位于某集工程内时排除其自集标题——本集文件以自己的片名开篇（H1/组件数组）
+    是自然形态，不该被计入顺序。
+    """
+    for f in files:
+        try:
+            text = f.read_text(encoding="utf-8")
+        except UnicodeDecodeError:
+            continue
+        segs = set(f.parts)
+        own = next(
+            (e for e in series["episodes"] if e["path"].split("/")[-1] in segs), None
+        )
+        present = [
+            (text.find(e["title"]), e["episode"], e["title"])
+            for e in series["episodes"]
+            if e["title"] in text and e is not own
+        ]
+        if len(present) >= 2:
+            seq = [ep for _, ep, _ in sorted(present)]  # 按文本首现位置排序
+            if seq != sorted(seq):
+                msgs.append(
+                    f"FAIL 规则2：{f.relative_to(REPO)} 中多集标题首现顺序为 "
+                    f"{[t for _, _, t in sorted(present)]}（episode 序 {seq}），与 series.json 顺序不符"
+                )
+
+
+def rule_ordinal_binding(series: dict, files: list[Path], msgs: list[str]) -> None:
+    """规则 3：`第N集` 的 ±60 字符窗口内出现的标题必须与该序号匹配。"""
+    by_ep = {e["episode"]: e["title"] for e in series["episodes"]}
+    title_to_ep = {e["title"]: e["episode"] for e in series["episodes"]}
+    for f in files:
+        if (
+            f.suffix != ".md"
+        ):  # 仅散文：TSX 里标签常在标题之后，近邻法必误报（规则2已覆盖数组）
+            continue
+        segs = set(f.parts)
+        own_ep = next(
+            (
+                e["episode"]
+                for e in series["episodes"]
+                if e["path"].split("/")[-1] in segs
+            ),
+            None,
+        )
+        try:
+            text = f.read_text(encoding="utf-8")
+        except UnicodeDecodeError:
+            continue
+        for m in EP_NUM.finditer(text):
+            if own_ep and CN_NUM.get(m.group(1)) == own_ep:
+                continue  # 本集自称序号合法（如 EP3 README 开篇「系列第三集」）
+            n = CN_NUM.get(m.group(1), 0)
+            if n not in by_ep:
+                continue
+            window = text[max(0, m.start() - 60) : m.end() + 60]
+            for title, ep in title_to_ep.items():
+                if title in window and ep != n:
+                    msgs.append(
+                        f"FAIL 规则3：{f.relative_to(REPO)} 「第{m.group(1)}集」邻域出现第 {ep} 集的标题《{title}》"
+                    )
+
+
+def rule_manifest_integrity(series: dict, msgs: list[str]) -> None:
+    """规则 4：清单完整性。"""
+    eps = series["episodes"]
+    nums = [e["episode"] for e in eps]
+    if nums != list(range(1, len(eps) + 1)):
+        msgs.append(f"FAIL 规则4：episode 序列 {nums} 不连续或有重复")
+    slugs = [e["slug"] for e in eps]
+    if len(set(slugs)) != len(slugs):
+        msgs.append("FAIL 规则4：slug 重复")
+    for e in eps:
+        root = REPO / e["path"]
+        for need in ("README.md", "script/narration.md"):
+            if not (root / need).is_file():
+                msgs.append(f"FAIL 规则4：{e['slug']} 缺 {need}")
+        theme = root / "video" / "src" / "design" / "theme.ts"
+        if theme.is_file():
+            src = theme.read_text(encoding="utf-8")
+            for hexv in e.get("accents", []):
+                if hexv not in src:
+                    msgs.append(
+                        f"FAIL 规则4：{e['slug']} 的 accents 色值 {hexv} 未出现在其 theme.ts"
+                    )
+        else:
+            msgs.append(f"WARN 规则4：{e['slug']} 缺 theme.ts（工程未初始化？）")
+
+
+def rule_dead_links(files: list[Path], msgs: list[str]) -> None:
+    """规则 5：受检文件内的相对链接目标必须存在。"""
+    for f in files:
+        try:
+            text = f.read_text(encoding="utf-8")
+        except UnicodeDecodeError:
+            continue
+        for m in REL_LINK_RE.finditer(text):
+            target = (f.parent / m.group(1)).resolve()
+            if not target.exists():
+                msgs.append(f"FAIL 规则5：{f.relative_to(REPO)} 死链 {m.group(1)}")
+
+
+def main() -> None:
+    series = load_series()
+    files = covered_files()
+    msgs: list[str] = []
+    rule_spoken_interleave(series, msgs)
+    rule_title_order(series, files, msgs)
+    rule_ordinal_binding(series, files, msgs)
+    rule_manifest_integrity(series, msgs)
+    rule_dead_links(files, msgs)
+
+    fails = [m for m in msgs if m.startswith("FAIL")]
+    warns = [m for m in msgs if m.startswith("WARN")]
+    for m in msgs:
+        print(f"  {m}")
+    print(
+        f">> 系列一致性 · 受检 {len(files)} 文件 · FAIL {len(fails)} · WARN {len(warns)}"
+    )
+    sys.exit(1 if fails else 0)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/media/pipeline/scripts/paper_extract.py b/media/pipeline/scripts/paper_extract.py
new file mode 100644
index 000000000..e83e107cf
--- /dev/null
+++ b/media/pipeline/scripts/paper_extract.py
@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+"""论文抽取工具（Stage ① 精读提取的取证工具箱）。
+
+为「逐句断言 → 论文锚点」的可回溯校准提供机械化取证手段，替代此前每轮
+临场手写的一次性 pymupdf 片段。五个子命令覆盖 Stage ① 的全部取证需求：
+
+    map       § 编号 → 页码映射（先建映射，后续锚点一律写 §x.y (pN)）
+    text      按页范围取正文，**默认分栏**（A4 双栏 LaTeX 直接 get_text 会交错两栏）
+    captions  图表 caption 收割（喂给分镜的动画规格）
+    find      逐条断言定点搜索，返回命中处上下文（校准表的主力）
+    render    指定页光栅化为 PNG（看图；无需 poppler/ffmpeg）
+
+依赖仅 pymupdf，从仓库根调用：
+
+    uv run --no-project --with pymupdf media/pipeline/scripts/paper_extract.py \\
+        "<论文.pdf>" find "far more frequently and cheaply"
+
+注意：论文 PDF 通常不入库（根 .gitignore 屏蔽 /assets/），须传绝对路径；
+文件名含 `:` 等字符时须加引号。
+"""
+
+from __future__ import annotations
+
+import argparse
+import re
+import sys
+from pathlib import Path
+
+try:
+    import pymupdf
+except ImportError:  # pragma: no cover - 依赖缺失时给可操作提示
+    sys.exit("缺少 pymupdf —— 请以 `uv run --no-project --with pymupdf` 方式调用本脚本")
+
+# § 标题行：编号 + 标题正文。要求标题以大写字母开头，排除正文里的「1. 」列表项
+SECTION_RE = re.compile(r"^\s*(\d+(?:\.\d+)*)\.?\s+([A-Z][^\n]{3,80})$", re.M)
+# 图表 caption：论文用 `Figure 1 | …` 与 `Table 1 | …`，也兼容 `:`/`.` 分隔
+CAPTION_RE = re.compile(r"(Figure|Table)\s+(\d+)\s*[|:.]?\s*(.{0,400})", re.S)
+
+
+def open_doc(path: str) -> pymupdf.Document:
+    p = Path(path).expanduser()
+    if not p.is_file():
+        sys.exit(f"PDF 不存在: {p}")
+    return pymupdf.open(p)
+
+
+def parse_pages(spec: str, page_count: int) -> list[int]:
+    """解析页码表达式为 0-based 页索引列表。支持 `12-24`、`1,7,8`、`3-5,9`。"""
+    pages: list[int] = []
+    for chunk in spec.split(","):
+        chunk = chunk.strip()
+        if not chunk:
+            continue
+        if "-" in chunk:
+            lo_s, _, hi_s = chunk.partition("-")
+            lo, hi = int(lo_s), int(hi_s)
+        else:
+            lo = hi = int(chunk)
+        if lo < 1 or hi > page_count or lo > hi:
+            sys.exit(f"页码区间越界: {chunk}（PDF 共 {page_count} 页）")
+        pages.extend(range(lo - 1, hi))
+    if not pages:
+        sys.exit("未解析出任何页码")
+    return pages
+
+
+def cmd_map(doc: pymupdf.Document, args: argparse.Namespace) -> None:
+    print(f"# § → 页码映射（共 {doc.page_count} 页）")
+    for i, page in enumerate(doc):
+        hits = SECTION_RE.findall(page.get_text("text"))
+        if hits:
+            joined = " · ".join(
+                f"{num} {title.strip()[:60]}"
+                for num, title in hits[: args.max_per_page]
+            )
+            print(f"p{i + 1:>3}  {joined}")
+
+
+def page_columns(page: pymupdf.Page, columns: int) -> list[str]:
+    """把一页按等宽竖切成 N 栏分别取文，避免双栏排版的行交错。"""
+    if columns <= 1:
+        return [page.get_text("text", sort=True)]
+    r = page.rect
+    width = (r.x1 - r.x0) / columns
+    out = []
+    for c in range(columns):
+        clip = pymupdf.Rect(r.x0 + c * width, r.y0, r.x0 + (c + 1) * width, r.y1)
+        out.append(page.get_text("text", clip=clip, sort=True))
+    return out
+
+
+def cmd_text(doc: pymupdf.Document, args: argparse.Namespace) -> None:
+    labels = "LMRSTUV"  # 栏标记，最多 7 栏够用
+    for i in parse_pages(args.pages, doc.page_count):
+        for c, chunk in enumerate(page_columns(doc[i], args.columns)):
+            tag = labels[c] if args.columns > 1 else ""
+            print(f"\n===== p{i + 1} {tag} =====")
+            print(chunk.rstrip())
+
+
+def cmd_captions(doc: pymupdf.Document, args: argparse.Namespace) -> None:
+    print("# 图表 caption 收割")
+    for i, page in enumerate(doc):
+        for m in CAPTION_RE.finditer(page.get_text("text", sort=True)):
+            body = " ".join(m.group(3).split())[: args.chars]
+            if len(body) < 12:  # 过滤正文里的「Figure 2 makes this explicit」式交叉引用
+                continue
+            print(f"p{i + 1:>3}  {m.group(1)} {m.group(2)}: {body}")
+
+
+def cmd_find(doc: pymupdf.Document, args: argparse.Namespace) -> None:
+    total = 0
+    for i, page in enumerate(doc):
+        for rect in page.search_for(args.query):
+            clip = pymupdf.Rect(
+                rect.x0 - args.context,
+                rect.y0 - 40,
+                rect.x1 + args.context,
+                rect.y1 + 80,
+            )
+            block = " ".join(page.get_text("text", clip=clip, sort=True).split())
+            print(f"p{i + 1:>3}  {block[: args.chars]}")
+            print("---")
+            total += 1
+            if args.limit and total >= args.limit:
+                print(f"（已达 --limit {args.limit}，停止）")
+                return
+    if total == 0:
+        # 命中为 0 是有意义的取证结果：说明该措辞不在论文里（例如编造的数字）
+        print(f"（未命中）query={args.query!r} —— 论文全文无此措辞")
+        sys.exit(1)
+
+
+def cmd_render(doc: pymupdf.Document, args: argparse.Namespace) -> None:
+    out_dir = Path(args.out).expanduser()
+    out_dir.mkdir(parents=True, exist_ok=True)
+    for i in parse_pages(args.pages, doc.page_count):
+        dest = out_dir / f"p{i + 1:03d}.png"
+        doc[i].get_pixmap(dpi=args.dpi).save(dest)
+        print(f"{dest}  ({dest.stat().st_size // 1024} KB)")
+    print(f"\n共 {len(parse_pages(args.pages, doc.page_count))} 页 → {out_dir}")
+    print("⚠️ 这些是论文原图的参考副本，仅供查看以撰写动画规格；不得入库、不得出片。")
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(
+        description="论文抽取工具（Stage ① 取证工具箱）",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=__doc__,
+    )
+    ap.add_argument("pdf", help="论文 PDF 路径（文件名含特殊字符时加引号）")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+
+    p = sub.add_parser("map", help="§ 编号 → 页码映射")
+    p.add_argument(
+        "--max-per-page", type=int, default=4, help="每页最多列出几个标题（默认 4）"
+    )
+    p.set_defaults(func=cmd_map)
+
+    p = sub.add_parser("text", help="按页范围取正文（默认双栏分列）")
+    p.add_argument("--pages", required=True, help="页码，如 12-24 或 1,7,8")
+    p.add_argument(
+        "--columns", type=int, default=2, help="分栏数，单栏排版传 1（默认 2）"
+    )
+    p.set_defaults(func=cmd_text)
+
+    p = sub.add_parser("captions", help="图表 caption 收割")
+    p.add_argument(
+        "--chars", type=int, default=300, help="每条 caption 截断长度（默认 300）"
+    )
+    p.set_defaults(func=cmd_captions)
+
+    p = sub.add_parser("find", help="定点搜索并返回上下文（未命中时退出码 1）")
+    p.add_argument("query", help="要检索的原文措辞")
+    p.add_argument("--context", type=int, default=280, help="左右扩展像素（默认 280）")
+    p.add_argument(
+        "--chars", type=int, default=400, help="每条上下文截断长度（默认 400）"
+    )
+    p.add_argument(
+        "--limit", type=int, default=6, help="最多返回几条，0 = 不限（默认 6）"
+    )
+    p.set_defaults(func=cmd_find)
+
+    p = sub.add_parser("render", help="指定页光栅化为 PNG（看图，无需 poppler）")
+    p.add_argument("--pages", required=True, help="页码，如 26,32,39,50")
+    p.add_argument("--out", required=True, help="输出目录（须在 gitignored 路径下）")
+    p.add_argument("--dpi", type=int, default=170, help="光栅化 DPI（默认 170）")
+    p.set_defaults(func=cmd_render)
+
+    args = ap.parse_args()
+    args.func(open_doc(args.pdf), args)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/media/pipeline/scripts/pipeline.py b/media/pipeline/scripts/pipeline.py
new file mode 100644
index 000000000..23a19cee1
--- /dev/null
+++ b/media/pipeline/scripts/pipeline.py
@@ -0,0 +1,379 @@
+#!/usr/bin/env python3
+"""科普视频管线单入口——九阶段中工具化阶段的薄编排。
+
+此前「跑管线」= 人从 README 复制粘贴命令序列，且每集的引擎/风格/样本参数
+散落三份 README（已实际漂移：README 仍教 passionate 而VOICE-CLONING 推荐位
+已迁移）。本入口从每集 pipeline.toml 装配默认参数，CLI 显式参数仍可覆盖。
+
+设计约束（刻意不做的事）：
+  - 不做阶段状态机/状态文件——幂等与续跑已由内容摘要提供（{id}.sha 逐句
+    sidecar；narration.json 是 narration.md 的纯函数派生），再存一份阶段状态
+    就是第二事实源，必然漂移。`status` 实时派生新鲜度，零存储。
+  - 不假装能跑写作阶段（①②④⑤中的人/代理部分）——只跑工具与其质量门。
+
+用法：uv run --no-project media/pipeline/scripts/pipeline.py <cmd> --project media/<工程>
+子命令：status / doctor / build / check / tts / captions / render / qa / all / clean-samples
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+import sys
+import time
+import tomllib
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+SCRIPTS = Path(__file__).resolve().parent
+REPO = SCRIPTS.parents[2]
+sys.path.insert(0, str(SCRIPTS))  # noqa: E402 - 复用 timeline 的 load_constants
+
+MANUAL = "media/pipeline/VOICE-CLONING.md"
+
+
+def load_config(root: Path) -> dict:
+    cfg_path = root / "pipeline.toml"
+    if not cfg_path.is_file():
+        sys.exit(
+            f"缺少分集配置: {cfg_path}\n  可执行参数已收敛至 pipeline.toml"
+            "（见 media/pipeline/README.md 字段表）；直接调用底层脚本亦可"
+        )
+    return tomllib.loads(cfg_path.read_text(encoding="utf-8"))
+
+
+def run(cmd: list[str], cwd: Path | None = None) -> int:
+    print(f"\n$ {' '.join(cmd)}" + (f"   (cwd={cwd})" if cwd else ""))
+    return subprocess.run(cmd, cwd=cwd, check=False).returncode
+
+
+def uv_no_project(
+    script: str, with_pkgs: list[str], *extra: str, project: Path
+) -> list[str]:
+    cmd = ["uv", "run", "--no-project"]
+    for p in with_pkgs:
+        cmd += ["--with", p]
+    cmd += [str(SCRIPTS / script), "--project", str(project), *extra]
+    return cmd
+
+
+# ---------------- 子命令 ----------------
+
+
+def cmd_status(root: Path, _cfg: dict) -> int:
+    """派生式阶段新鲜度表（无状态文件：全部由产物 mtime/摘要实时推断）。"""
+    from timeline import load_constants
+
+    narr_md = root / "script" / "narration.md"
+    narr_json = root / "script" / "narration.json"
+    board = root / "script" / "storyboard.md"
+    manifest = root / "video" / "public" / "audio" / "manifest.json"
+    draft = root / "out" / "draft.mp4"
+    final = root / "out" / "final.mp4"
+
+    def fresh(target: Path, *deps: Path) -> str:
+        if not target.is_file():
+            return "待产出"
+        tt = target.stat().st_mtime
+        stale = [d.name for d in deps if d.is_file() and d.stat().st_mtime > tt]
+        return f"⚠️ 输入已更新（{', '.join(stale)}）" if stale else "✅ 新鲜"
+
+    print(f">> {root.name} 阶段新鲜度（实时派生，无状态文件）")
+    print(f"  ③ narration.json    {fresh(narr_json, narr_md)}")
+    print(f"  ⑥ audio/manifest    {fresh(manifest, narr_json)}")
+    if manifest.is_file():
+        items = json.loads(manifest.read_text(encoding="utf-8"))
+        done = sum(
+            1
+            for i in items
+            if (root / "video/public/audio" / f"{i['id']}.mp3").is_file()
+        )
+        c = load_constants(root)
+        from timeline import total_duration_in_frames
+
+        mins = total_duration_in_frames(items, c) / c["fps"] / 60
+        print(f"     {done}/{len(items)} 句 mp3 · 预计成片 {mins:.1f} 分钟")
+    print(f"  ⑧ out/draft.mp4     {fresh(draft, manifest, board)}")
+    print(
+        f"  ⑨ out/final.mp4     {final.is_file() and fresh(final, draft) or '待产出'}"
+    )
+    return 0
+
+
+def cmd_doctor(root: Path, cfg: dict) -> int:
+    """环境自检：配置、时序 SSOT、参考样本、IndexTTS 服务、node_modules。"""
+    ok = True
+    tts = cfg.get("tts", {})
+    print(">> doctor")
+    from timeline import load_constants
+
+    try:
+        c = load_constants(root)
+        print(
+            f"  ✅ timing.json: fps={c['fps']} 句间={c['sentenceGapSec']}s 幕间={c['sceneGapSec']}s"
+        )
+    except SystemExit as e:
+        print(f"  ❌ {e}")
+        ok = False
+    if tts.get("engine") == "indextts":
+        ref = REPO / tts.get("ref", "")
+        if ref.is_file():
+            import hashlib
+
+            sha1 = hashlib.sha1(ref.read_bytes()).hexdigest()[:12]
+            match = "✅" if sha1 == tts.get("ref_sha1") else "❌ 指纹不符"
+            print(f"  {match} 参考样本 {ref.name} sha1={sha1}")
+            ok = ok and sha1 == tts.get("ref_sha1")
+        else:
+            print(f"  ⚠️  参考样本缺失: {ref}（音频不入库；用 refs.py rebuild 重建）")
+        try:
+            server = tts.get("server", "http://127.0.0.1:8766")
+            with urllib.request.urlopen(f"{server}/health", timeout=5) as resp:
+                h = json.loads(resp.read())
+            print(
+                f"  ✅ IndexTTS 服务: v{h.get('version')} {h.get('device')}/{h.get('dtype')}"
+            )
+        except (urllib.error.URLError, OSError) as e:
+            print(f"  ❌ IndexTTS 服务不可达: {e}（启动命令见 {MANUAL} §二）")
+            ok = False
+    if not (root / "video" / "node_modules").is_dir():
+        print(
+            "  ⚠️  video/node_modules 未安装（渲染前: cd video && pnpm install --ignore-workspace）"
+        )
+    print(
+        "  ℹ️  渲染主机约束：macOS + PingFang SC/Songti SC 系统字体（Linux/CI 渲染不在支持范围）"
+    )
+    return 0 if ok else 1
+
+
+def cmd_build(root: Path, _cfg: dict) -> int:
+    return run(uv_no_project("build_narration.py", [], project=root))
+
+
+def cmd_check(root: Path, _cfg: dict, scenes: bool = False) -> int:
+    extra = ["--check-scenes"] if scenes else []
+    return run(uv_no_project("check_script.py", [], *extra, project=root))
+
+
+def cmd_tts(
+    root: Path,
+    cfg: dict,
+    plan: bool,
+    force: bool,
+    steady: str | None,
+    style: str | None,
+    allow_voice_switch: bool = False,
+) -> int:
+    tts = cfg.get("tts", {})
+    cmd = [
+        "uv",
+        "run",
+        "--no-project",
+        "--with",
+        "mutagen",
+        str(root / "scripts" / "tts.py"),  # 工程内薄包装（注入 --project）
+        "--engine",
+        tts.get("engine", "indextts"),
+    ]
+    if tts.get("engine", "indextts") == "indextts":
+        cmd += ["--ref", str(REPO / tts["ref"])]
+        if tts.get("ref_sha1"):
+            cmd += ["--expect-ref-sha1", tts["ref_sha1"]]
+        cmd += [
+            "--style",
+            style or tts.get("style", "sunny-steady"),
+            "--lang",
+            tts.get("lang", "ZH"),
+        ]
+    if plan:
+        cmd.append("--plan")
+    if force:
+        cmd.append("--force")
+    if steady:
+        cmd += ["--steady", steady]
+    if allow_voice_switch:
+        # 两遍法经单入口的放行阀：.engine 签名护栏会拦「换风格=整集重录」，
+        # 草稿遍(A)/定稿遍(B)任一换档都须显式带上（护栏原理见 tts.py §音色签名）
+        cmd.append("--allow-voice-switch")
+    return run(cmd, cwd=root)
+
+
+def cmd_captions(root: Path, _cfg: dict) -> int:
+    return run(uv_no_project("captions.py", [], project=root))
+
+
+def cmd_render(root: Path, cfg: dict, final: bool) -> int:
+    video = root / "video"
+    if not (video / "node_modules").is_dir():
+        print("先安装依赖（--ignore-workspace 隔离根 workspace）…")
+        rc = run(["pnpm", "install", "--ignore-workspace"], cwd=video)
+        if rc:
+            return rc
+    r = cfg.get("render", {})
+    out = "../out/final.mp4" if final else "../out/draft.mp4"
+    cmd = ["./node_modules/.bin/remotion", "render", "Main", out]
+    if not final:
+        cmd += [
+            "--scale",
+            str(r.get("draft_scale", 0.5)),
+            "--jpeg-quality",
+            str(r.get("draft_jpeg_quality", 60)),
+        ]
+    return run(cmd, cwd=video)
+
+
+def cmd_qa(
+    root: Path,
+    cfg: dict,
+    video: str | None,
+    scene: str | None,
+    last_n: int | None,
+    ids: list[str],
+    check: bool,
+    scale: float | None,
+) -> int:
+    cmd = ["uv", "run", "--no-project"]
+    if check:
+        cmd += ["--with", "pillow", "--with", "numpy"]
+    cmd += [str(SCRIPTS / "qa_frames.py"), "--project", str(root)]
+    if scene:
+        cmd += ["--scene", scene]
+    if last_n:
+        cmd += ["--last-n", str(last_n)]
+    if check:
+        cmd += ["--check"]
+        # 字幕带/亮块间隔是全分辨率像素常数：草渲（0.5x）不折算则带高×2、间隔×2，
+        # 侵入判据双向失真。显式 --scale 优先；未给时按产物名推断（draft → pipeline.toml）
+        eff = scale
+        if eff is None and video and Path(video).name == "draft.mp4":
+            eff = cfg.get("render", {}).get("draft_scale", 0.5)
+        if eff is not None:
+            cmd += ["--scale", str(eff)]
+    if video:
+        cmd.append(video)
+    cmd += ids
+    return run(cmd, cwd=root)
+
+
+def cmd_all(root: Path, cfg: dict) -> int:
+    """build → check → tts → captions → render --draft → qa 抽帧（含自动体检）。"""
+    for step in (
+        lambda: cmd_build(root, cfg),
+        lambda: cmd_check(root, cfg),
+        lambda: cmd_tts(root, cfg, plan=False, force=False, steady=None, style=None),
+        lambda: cmd_captions(root, cfg),
+        lambda: cmd_render(root, cfg, final=False),
+    ):
+        if rc := step():
+            return rc
+    print("\n>> 草渲完成。尾幕必查（渐黑过早缺陷的回归点）：")
+    # 全部路径用绝对值：脚本/工程/视频各自相对不同 CWD，混用相对路径则任一工作目录照抄必有一端落空
+    print(
+        f"   uv run --no-project --with pillow --with numpy {SCRIPTS / 'qa_frames.py'} \\"
+    )
+    print(
+        f"       --project {root} {root / 'out' / 'draft.mp4'} --last-n 6 --check"
+        f" --scale {cfg.get('render', {}).get('draft_scale', 0.5)}   # 草渲像素折算，不可省"
+    )
+    return 0
+
+
+def cmd_clean_samples(_root: Path, _cfg: dict) -> int:
+    d = REPO / ".temp" / "voice-samples"
+    if d.is_dir():
+        import shutil
+
+        shutil.rmtree(d)
+        print(f"已删除 {d}（小样含本人音色，属生物特征信息）")
+    else:
+        print(f"无待清理目录: {d}")
+    return 0
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(
+        description="科普视频管线单入口（薄编排，阶段契约见 media/pipeline/README.md）"
+    )
+    ap.add_argument(
+        "--project",
+        default=".",
+        help="视频工程根目录（含 pipeline.toml）；须置于子命令之前",
+    )
+    sub = ap.add_subparsers(dest="cmd", required=True)
+    sub.add_parser("status", help="阶段新鲜度（实时派生）")
+    sub.add_parser("doctor", help="环境自检")
+    sub.add_parser("build", help="③ narration.md → narration.json")
+    p = sub.add_parser("check", help="④⑤ 内容门")
+    p.add_argument(
+        "--check-scenes",
+        action="store_true",
+        help="附:分镜↔场景代码 beat 互比（WARN-only）",
+    )
+    sub.add_parser("captions", help="⑥+ 导出 srt/vtt")
+    sub.add_parser("clean-samples", help="清理 .temp/voice-samples（生物特征）")
+    p = sub.add_parser("tts", help="⑥ 配音合成（参数来自 pipeline.toml）")
+    p.add_argument("--plan", action="store_true", help="只看排期不实跑")
+    p.add_argument("--force", action="store_true", help="忽略缓存")
+    p.add_argument("--steady", help="混合档选择器")
+    p.add_argument("--style", help="覆写风格（两遍法草稿遍用 --style sunny）")
+    p.add_argument(
+        "--allow-voice-switch",
+        action="store_true",
+        help="放行音色签名变更（两遍法换档经单入口时须带上，否则被 .engine 护栏硬拦）",
+    )
+    p = sub.add_parser("render", help="⑧⑨ 渲染")
+    p.add_argument("--final", action="store_true", help="终渲（默认草渲）")
+    p = sub.add_parser("qa", help="⑧ 抽帧 QA")
+    p.add_argument("--video", help="渲染产物路径")
+    p.add_argument("--scene")
+    p.add_argument("--last-n", type=int)
+    p.add_argument("--check", action="store_true", help="自动体检")
+    p.add_argument(
+        "--scale",
+        type=float,
+        help="产物缩放系数（草渲不传时按 draft.mp4 自动取 pipeline.toml 的 draft_scale）",
+    )
+    p.add_argument("ids", nargs="*")
+    sub.add_parser("all", help="build→check→tts→captions→render(草渲) 一键链")
+    args = ap.parse_args()
+
+    root = Path(args.project).resolve()
+    cfg = load_config(root)
+    t0 = time.time()
+    rc = {
+        "status": lambda: cmd_status(root, cfg),
+        "doctor": lambda: cmd_doctor(root, cfg),
+        "build": lambda: cmd_build(root, cfg),
+        "check": lambda: cmd_check(root, cfg, args.check_scenes),
+        "tts": lambda: cmd_tts(
+            root,
+            cfg,
+            args.plan,
+            args.force,
+            args.steady,
+            args.style,
+            args.allow_voice_switch,
+        ),
+        "captions": lambda: cmd_captions(root, cfg),
+        "render": lambda: cmd_render(root, cfg, args.final),
+        "qa": lambda: cmd_qa(
+            root,
+            cfg,
+            args.video,
+            args.scene,
+            args.last_n,
+            args.ids,
+            args.check,
+            args.scale,
+        ),
+        "all": lambda: cmd_all(root, cfg),
+        "clean-samples": lambda: cmd_clean_samples(root, cfg),
+    }[args.cmd]()
+    print(f"\n>> {args.cmd} 完成（{time.time() - t0:.1f}s，退出码 {rc}）")
+    sys.exit(rc)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/media/pipeline/scripts/prepare_ref.py b/media/pipeline/scripts/prepare_ref.py
index 6b3b61692..f6a286cdd 100644
--- a/media/pipeline/scripts/prepare_ref.py
+++ b/media/pipeline/scripts/prepare_ref.py
@@ -28,7 +28,8 @@ def main() -> int:
         description="裁剪/规范化参考音色样本 → 16-bit 单声道 WAV"
     )
     parser.add_argument(
-        "source", help="源音频文件（mp3/wav/flac 等 soundfile 可读格式；m4a 需先 ffmpeg 转 wav）"
+        "source",
+        help="源音频文件（mp3/wav/flac 等 soundfile 可读格式；m4a 需先 ffmpeg 转 wav）",
     )
     parser.add_argument(
         "--start", type=float, default=0.0, help="裁剪起点（秒，默认 0）"
diff --git a/media/pipeline/scripts/prospect_ref.py b/media/pipeline/scripts/prospect_ref.py
index 72b0099cd..a21f76b9c 100644
--- a/media/pipeline/scripts/prospect_ref.py
+++ b/media/pipeline/scripts/prospect_ref.py
@@ -166,7 +166,7 @@ def main() -> int:
         - 20.0 * np.maximum(0, sil - 0.22)
         - 15.0 * np.maximum(0, 0.45 - voiced)
     )
-    for r, s in zip(rows, score):
+    for r, s in zip(rows, score, strict=True):
         r["score"] = float(s)
 
     print(
diff --git a/media/pipeline/scripts/qa_frames.py b/media/pipeline/scripts/qa_frames.py
index 918ae30bf..366754fe0 100644
--- a/media/pipeline/scripts/qa_frames.py
+++ b/media/pipeline/scripts/qa_frames.py
@@ -1,77 +1,298 @@
 #!/usr/bin/env python3
-"""按句 id 从渲染产物中抽帧，用于视觉 QA——公共管线版本。
+"""按句 id 从渲染产物中抽帧 + 自动视觉体检——公共管线版本。
 
-时序常量须与工程的 video/src/timing.ts 保持一致（FPS/句间停顿/幕间停顿/片头引导）。
-若工程自定义了 timing 常量，须同步本文件顶部的镜像常量。
+时序常数直读 <工程>/video/src/timing.json（单一事实源，与 timing.ts / captions.py
+同源），镜像常量已删除——工程改节奏只动 timing.json，本脚本自动跟随。
 
-用法：uv run --no-project media/pipeline/scripts/qa_frames.py --project media/<工程> \
-          <video.mp4> <句id> [句id ...]
-     uv run --no-project media/pipeline/scripts/qa_frames.py --project media/<工程> \
-          <video.mp4> --scene P1        # 该幕抽样至多 ~8 帧（与 ids 二选一）
-输出：<工程>/out/frames/{句id}.png
+抽帧选择器（三选一）：
+    <video.mp4> <句id>…            指定句（句中点帧）
+    <video.mp4> --scene P1         该幕抽样至多 ~8 帧
+    <video.mp4> --last-n 6         末 N 句——直指「末句短于 beat → 渐黑提前 → 长黑尾」
+                                   上线 bug 的抽样盲区（尾幕必查）
+
+自动体检（--check，惰性依赖 pillow+numpy）：
+    黑帧/早渐黑    帧平均相对亮度 < 0.02 → FAIL（仅末 beat 且分镜末行写「渐黑」时豁免）
+    字幕区侵入     字幕带 y∈[H-160,H) 内、字幕框 x 区间之外有独立亮列连通段 → WARN
+                   （对应 skills/06 渲染缺陷清单第 2 条「角标 bottom ≥ 150」）
+    冻帧           同幕相邻采样帧 16×16 灰度均值哈希 Hamming 距离 0 → WARN
+                   （beat 窗口错位/未覆盖句区间渲染空白）
+    字幕缺失       字幕带内无任何像素达文字亮度 → WARN（单句字幕渲染失败）
+
+主题对比度（--check-theme，零依赖、不需要视频）：
+    解析 video/src/design/theme.ts 的 #RRGGBB，按 WCAG 2.x 相对亮度对比
+    theme.bg；概念色 < 4.5:1 → FAIL（此前只能肉眼估，见 skills/06 清单）。
+
+用法：uv run --no-project [--with pillow --with numpy] media/pipeline/scripts/qa_frames.py \
+          --project media/<工程> <video.mp4> [--scene P2|--last-n 6|句id…] [--check]
+     uv run --no-project media/pipeline/scripts/qa_frames.py --project media/<工程> --check-theme
+输出：抽帧 <工程>/out/frames/{句id}.png；体检结果打屏，FAIL 使退出码非零。
 """
 
 from __future__ import annotations
 
 import argparse
 import json
+import re
 import subprocess
+import sys
 from pathlib import Path
 
-# 与各工程 video/src/timing.ts 对齐（管线默认值；改过 timing 的工程须同步）
-FPS = 30
-SENTENCE_GAP = 0.32
-SCENE_GAP = 0.9
-LEAD_IN = 0.6
+sys.path.insert(0, str(Path(__file__).resolve().parent))  # noqa: E402 - 导入同目录 timeline
+from timeline import compute, load_constants  # noqa: E402
+
+#: theme.ts 中颜色令牌（'#RRGGBB' 字面量）；bg 单独作为对比基准
+THEME_COLOR_RE = re.compile(r"^\s{2}(?P<key>\w+):\s*'(?P<val>#[0-9A-Fa-f]{6})'", re.M)
 
 
-def timeline(manifest: Path) -> dict[str, tuple[float, float]]:
+def timeline(root: Path) -> dict[str, tuple[float, float]]:
+    """读 manifest + timing.json，返回 {句id: (startSec, spanSec)}。"""
+    manifest = root / "video" / "public" / "audio" / "manifest.json"
+    if not manifest.is_file():
+        sys.exit(f"manifest.json 不存在: {manifest} —— 先运行 scripts/tts.py 合成配音")
     items = json.loads(manifest.read_text(encoding="utf-8"))
-    result: dict[str, tuple[float, float]] = {}
-    cursor_frames = round(LEAD_IN * FPS)
-    for i, item in enumerate(items):
-        nxt = items[i + 1] if i + 1 < len(items) else None
-        gap = SENTENCE_GAP + (SCENE_GAP if nxt and nxt["scene"] != item["scene"] else 0)
-        dur_frames = max(1, round((item["durationSec"] + gap) * FPS))
-        result[item["id"]] = (cursor_frames / FPS, dur_frames / FPS)
-        cursor_frames += dur_frames
-    return result
+    c = load_constants(root)
+    return {r["id"]: (r["startSec"], r["spanSec"]) for r in compute(items, c)}
+
+
+def extract_frame(
+    ffmpeg: list[str], video: Path, cwd: Path, ts: float, dst: Path
+) -> None:
+    try:
+        subprocess.run(
+            [
+                *ffmpeg,
+                "-y",
+                "-ss",
+                f"{ts:.3f}",
+                "-i",
+                str(video),
+                "-frames:v",
+                "1",
+                "-update",
+                "1",
+                str(dst),
+            ],
+            cwd=cwd,
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+    except subprocess.CalledProcessError as e:
+        print(f"ffmpeg 失败({dst.stem}): {(e.stderr or '')[-500:]}")
+        raise
+
+
+# ---------------- 自动体检（--check / --check-theme） ----------------
+
+#: 亮度/对比阈值（经验值：深色底 #0E1116 的相对亮度 ≈ 0.006）
+BLACK_MEAN_LIMIT = 0.02
+SUBTITLE_BAND_PX = 160  # 字幕安全带高度（对应「bottom ≥ 150」清单位）
+SUBTITLE_GAP_PX = 80  # 字幕框与角标亮块的横向最小间隔（全分辨率口径，随 --scale 折算）
+TEXT_BRIGHTNESS = 0.45
+CONTRAST_MIN = 4.5
+
+
+def rel_luminance(r: int, g: int, b: int) -> float:
+    def ch(v: float) -> float:
+        return v / 12.92 if v <= 0.03928 else ((v + 0.055) / 1.055) ** 2.4
+
+    return 0.2126 * ch(r / 255) + 0.7152 * ch(g / 255) + 0.0722 * ch(b / 255)
+
+
+def wcag_ratio(fg: tuple[int, int, int], bg: tuple[int, int, int]) -> float:
+    l1, l2 = rel_luminance(*fg), rel_luminance(*bg)
+    hi, lo = max(l1, l2), min(l1, l2)
+    return (hi + 0.05) / (lo + 0.05)
+
+
+def check_theme(root: Path, msgs: list[str]) -> None:
+    theme = root / "video" / "src" / "design" / "theme.ts"
+    if not theme.is_file():
+        sys.exit(f"theme.ts 不存在: {theme}")
+    colors = {
+        m.group("key"): m.group("val")
+        for m in THEME_COLOR_RE.finditer(theme.read_text(encoding="utf-8"))
+    }
+    if "bg" not in colors:
+        sys.exit(f"{theme} 未解析出 bg 颜色令牌")
+
+    def hex_rgb(h: str) -> tuple[int, int, int]:
+        return int(h[1:3], 16), int(h[3:5], 16), int(h[5:7], 16)
+
+    bg = hex_rgb(colors["bg"])
+    print(f">> 主题对比度 · 基准 bg {colors['bg']}")
+    for key, val in colors.items():
+        if key in ("bg", "panel", "panelBorder") or key.endswith("Deep"):
+            continue  # 容器/描边色不承载正文信息
+        ratio = wcag_ratio(hex_rgb(val), bg)
+        mark = "✅" if ratio >= CONTRAST_MIN else "❌"
+        print(f"  {mark} {key:<10} {val}  对 bg 对比度 {ratio:.2f}:1")
+        if ratio < CONTRAST_MIN:
+            msgs.append(
+                f"FAIL {key} {val} 对 bg 对比度 {ratio:.2f}:1 < {CONTRAST_MIN}（skills/06 视觉契约：概念色须 ≥4.5:1）"
+            )
+
+
+def mean_hash(gray) -> int:
+    """16×16 灰度均值哈希（dHash 简化版）：以均值为阈值的位图指纹。"""
+    bits = 0
+    avg = float(gray.mean())
+    for v in gray.flatten():
+        bits = (bits << 1) | (1 if float(v) > avg else 0)
+    return bits
+
+
+def tail_row_has_fade(board: Path) -> bool:
+    """分镜表**最后一个表格行**（`| … |`）是否含「渐黑」——末 beat 渐黑豁免判据。
+
+    按表格行而非文件末行：分镜表末尾常跟「字幕规范/实现映射」散文节，
+    文件末 5 行判定会让豁免永不命中（EP1/EP2 实测如此，渐黑行距文件末约 10 行）。
+    """
+    if not board.is_file():
+        return False
+    rows = [
+        ln
+        for ln in board.read_text(encoding="utf-8").splitlines()
+        if ln.strip().startswith("|")
+    ]
+    return bool(rows) and any("渐黑" in ln for ln in rows[-2:])
+
+
+def check_frames(
+    out: Path, ids: list[str], scale: float, fade_exempt_last: bool, msgs: list[str]
+) -> None:
+    try:
+        import numpy as np
+        from PIL import Image
+    except ImportError:
+        sys.exit(
+            "--check 需要 pillow 与 numpy：uv run --no-project --with pillow --with numpy …"
+        )
+
+    band_px = round(SUBTITLE_BAND_PX * scale)
+    gap_px = round(SUBTITLE_GAP_PX * scale)  # 横向间隔阈值与带高同口径折算
+    hashes: dict[str, int] = {}
+    ordered: list[tuple[str, Path]] = []
+    for sid in ids:
+        png = out / f"{sid}.png"
+        if not png.is_file():
+            continue
+        ordered.append((sid, png))
+        img = np.asarray(Image.open(png).convert("L"), dtype=np.float32) / 255.0
+        mean = float(img.mean())
+        is_last = ordered.index((sid, png)) == len(ids) - 1
+        if mean < BLACK_MEAN_LIMIT and not (fade_exempt_last and is_last):
+            msgs.append(
+                f"FAIL {sid}: 帧平均亮度 {mean:.4f} < {BLACK_MEAN_LIMIT}（黑帧/渐黑过早）"
+            )
+        band = img[img.shape[0] - band_px :, :] if band_px else img
+        bright_px = float((band > TEXT_BRIGHTNESS).mean())
+        if bright_px == 0:
+            msgs.append(f"WARN {sid}: 字幕带内无文字亮度像素（字幕缺失？）")
+        else:
+            # 侵入检测按「亮列连通段」做：字幕框 = 最宽连通段；与它保持 >80px 间隔的
+            # 其他亮段 = 角标/图形侵入字幕安全带（单纯 min–max 会被远端角标吞掉边界）
+            col = band.max(axis=0)
+            bright = col > TEXT_BRIGHTNESS
+            segments: list[tuple[int, int]] = []
+            i = 0
+            while i < len(col):
+                if bright[i]:
+                    j = i
+                    while j < len(col) and bright[j]:
+                        j += 1
+                    segments.append((i, j - 1))
+                    i = j
+                else:
+                    i += 1
+            if segments:
+                x0, x1 = max(segments, key=lambda s: s[1] - s[0])  # 最宽段 = 字幕框
+                for a, b in segments:
+                    if (a < x0 - gap_px or a > x1 + gap_px) and (b - a) < (x1 - x0):
+                        msgs.append(
+                            f"WARN {sid}: 字幕带内字幕框（x{x0}–{x1}）之外有独立亮块 x{a}–{b}"
+                            f"（角标/图形侵入 bottom≥{SUBTITLE_BAND_PX}px 安全区）"
+                        )
+        hashes[sid] = mean_hash(
+            np.asarray(Image.open(png).convert("L").resize((16, 16)))
+        )
+
+    for (a, _), (b, _) in zip(ordered, ordered[1:], strict=False):
+        if a.rsplit("-", 1)[0][:2] == b.rsplit("-", 1)[0][:2]:  # 同幕前缀
+            if hashes[a] == hashes[b]:
+                msgs.append(f"WARN {a} 与 {b} 帧指纹相同（疑似冻帧/beat 窗口错位）")
+
+
+# ---------------- main ----------------
 
 
 def main() -> None:
-    parser = argparse.ArgumentParser(description="按句 id 抽帧视觉 QA")
+    parser = argparse.ArgumentParser(
+        description="按句 id 抽帧视觉 QA + 自动体检",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=__doc__,
+    )
     parser.add_argument(
         "--project", default=".", help="视频工程根目录（含 video/ 与 out/）"
     )
-    parser.add_argument("--scene", help="按幕抽样（如 P1），与位置参数 ids 二选一")
+    parser.add_argument("--scene", help="按幕抽样（如 P1）")
+    parser.add_argument("--last-n", type=int, help="抽末 N 句（尾幕渐黑必查）")
+    parser.add_argument(
+        "--check", action="store_true", help="对抽出的帧做自动体检（需 pillow+numpy）"
+    )
+    parser.add_argument(
+        "--check-theme",
+        action="store_true",
+        help="只做主题对比度检查（零依赖，无需视频）",
+    )
+    parser.add_argument(
+        "--scale",
+        type=float,
+        default=1.0,
+        help="渲染产物缩放系数（草渲 0.5），供字幕带像素折算",
+    )
     parser.add_argument(
         "--offset",
         type=float,
         default=0.0,
         help="时间轴整体偏移（草渲与终渲时间基准不一致时用）",
     )
-    parser.add_argument("video", help="渲染产物 mp4 路径")
-    parser.add_argument("ids", nargs="*", help="句 id 列表（与 --scene 二选一）")
+    parser.add_argument("video", nargs="?", help="渲染产物 mp4 路径")
+    parser.add_argument("ids", nargs="*", help="句 id 列表")
     args = parser.parse_args()
-    if bool(args.scene) == bool(args.ids):
-        parser.error("ids 与 --scene 必须二选一")
 
     root = Path(args.project).resolve()
+
+    if args.check_theme:
+        msgs: list[str] = []
+        check_theme(root, msgs)
+        for m in msgs:
+            print(f"  {m}")
+        print(f">> --check-theme · FAIL {sum(m.startswith('FAIL') for m in msgs)}")
+        sys.exit(1 if any(m.startswith("FAIL") for m in msgs) else 0)
+
+    selectors = sum(bool(x) for x in (args.scene, args.last_n, args.ids))
+    if not args.video or selectors != 1:
+        parser.error(
+            "需要 <video> 且 --scene / --last-n / ids 三选一（或用 --check-theme）"
+        )
+
     video = Path(args.video).resolve()
-    manifest = root / "video" / "public" / "audio" / "manifest.json"
     out = root / "out" / "frames"
-
-    tl = timeline(manifest)
+    tl = timeline(root)
     offset = args.offset
     if args.scene:
         prefix = args.scene.lower() + "-"
         ids = [k for k in tl if k.startswith(prefix)]
         ids = ids[:: max(1, len(ids) // 8)]  # 每幕最多抽 ~8 帧
+    elif args.last_n:
+        ids = list(tl)[-args.last_n :]
     else:
         ids = args.ids
 
     out.mkdir(parents=True, exist_ok=True)
     ffmpeg = ["pnpm", "exec", "remotion", "ffmpeg"]
+    extracted: list[str] = []
     for sid in ids:
         if sid not in tl:
             print(f"跳过未知句 id: {sid}")
@@ -79,31 +300,26 @@ def main() -> None:
         start, dur = tl[sid]
         ts = start + dur / 2 - offset
         dst = out / f"{sid}.png"
-        try:
-            subprocess.run(
-                [
-                    *ffmpeg,
-                    "-y",
-                    "-ss",
-                    f"{ts:.3f}",
-                    "-i",
-                    str(video),
-                    "-frames:v",
-                    "1",
-                    "-update",
-                    "1",
-                    str(dst),
-                ],
-                cwd=root / "video",
-                check=True,
-                capture_output=True,
-                text=True,
-            )
-        except subprocess.CalledProcessError as e:
-            print(f"ffmpeg 失败({sid}): {(e.stderr or '')[-500:]}")
-            raise
+        extract_frame(ffmpeg, video, root / "video", ts, dst)
+        extracted.append(sid)
         print(f"{sid} @ {ts:.2f}s -> {dst.relative_to(root)}")
 
+    if args.check:
+        # 末 beat 渐黑豁免：分镜**最后一个表格行**含「渐黑」字样时，最后一个抽帧允许黑。
+        # 按表格行而非文件末行——分镜表末尾常跟「字幕规范/实现映射」散文节，文件末行
+        # 判定会让豁免永不命中（EP1/EP2 实测如此）。
+        board = root / "script" / "storyboard.md"
+        fade_tail = tail_row_has_fade(board)
+        msgs: list[str] = []
+        check_frames(out, extracted, args.scale, fade_tail, msgs)
+        for m in msgs:
+            print(f"  {m}")
+        n_fail = sum(m.startswith("FAIL") for m in msgs)
+        print(
+            f">> 自动体检 · FAIL {n_fail} · WARN {sum(m.startswith('WARN') for m in msgs)}"
+        )
+        sys.exit(1 if n_fail else 0)
+
 
 if __name__ == "__main__":
     main()
diff --git a/media/pipeline/scripts/refs.py b/media/pipeline/scripts/refs.py
new file mode 100644
index 000000000..ec09ee0c6
--- /dev/null
+++ b/media/pipeline/scripts/refs.py
@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+"""参考音色样本可复现清单——不存音频，只存「怎么造出来的」与指纹。
+
+背景：voices/ 目录因生物特征隐私整目录 gitignore，导致「官方」样本参数与
+sha1 只活在文档散文里（me-bright.wav 的 54b699cce97f 散见 VOICE-CLONING.md
+三处）。换机器/换源文件后无人能自证复现了同一个音色，而 sunny/sunny-steady
+的 alpha 标定**因果地**依赖 me-bright 这个选段——复现错了，10 小时的成片
+合成就在错误的音色上跑完。
+
+本脚本 + voices/refs.toml（唯一入库文件，含 .gitignore 白名单例外）补上这条链：
+
+    verify   重算盘上 WAV 指纹，对照清单报「一致 / 不一致 / 缺失」
+    rebuild  按清单记录的参数转调 prepare_ref.py 重建样本，再自动 verify
+    list     列出清单条目
+
+用法（仓库根，零第三方依赖；rebuild 才需要 soundfile/numpy）：
+    uv run --no-project media/pipeline/scripts/refs.py list
+    uv run --no-project media/pipeline/scripts/refs.py verify [--name me-bright]
+    uv run --no-project --with soundfile --with numpy media/pipeline/scripts/refs.py \
+        rebuild --name me-bright
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import subprocess
+import sys
+import tomllib
+from pathlib import Path
+
+SCRIPTS_DIR = Path(__file__).resolve().parent
+REFS_TOML = SCRIPTS_DIR.parent / "voices" / "refs.toml"
+VOICES_DIR = REFS_TOML.parent
+#: 源录音为本人私有文件，仅记录相对家目录路径占位；真实路径在清单里以 ~ 展开
+PREPARE_REF = SCRIPTS_DIR / "prepare_ref.py"
+
+
+def load_refs() -> dict:
+    if not REFS_TOML.is_file():
+        sys.exit(f"清单不存在: {REFS_TOML}")
+    return tomllib.loads(REFS_TOML.read_text(encoding="utf-8"))
+
+
+def digest(path: Path) -> tuple[str, str]:
+    data = path.read_bytes()
+    return hashlib.sha1(data).hexdigest()[:12], hashlib.sha256(data).hexdigest()
+
+
+def cmd_list(refs: dict) -> None:
+    print(f"清单：{REFS_TOML}")
+    for name, r in refs.items():
+        print(
+            f"  {name:<10} {r['source']} --start {r['start']} --duration {r['duration']}"
+            f"  sha1 {r['sha1']}  锁定风格 {','.join(r.get('locked_styles', []))}"
+        )
+
+
+def cmd_verify(refs: dict, args: argparse.Namespace) -> int:
+    names = [args.name] if args.name else list(refs)
+    failures = 0
+    for name in names:
+        r = refs.get(name)
+        if r is None:
+            print(f"❌ {name}: 清单无此条目")
+            failures += 1
+            continue
+        wav = VOICES_DIR / f"{name}.wav"
+        if not wav.is_file():
+            print(
+                f"⚠️  {name}: 盘上缺失（{wav}）——音频不入库属预期；需要时用 rebuild 重建后复验"
+            )
+            continue
+        sha1, sha256 = digest(wav)
+        if sha1 == r["sha1"]:
+            print(f"✅ {name}: sha1 一致（{sha1}）")
+        else:
+            print(
+                f"❌ {name}: sha1 不一致 —— 清单 {r['sha1']} vs 盘上 {sha1}\n"
+                f"   源文件或重采样路径已变，勿在未核验音色上跑长合成；"
+                f"若确为新样本，请更新 {REFS_TOML}"
+            )
+            failures += 1
+            continue
+        if r.get("sha256") and sha256 != r["sha256"]:
+            print(f"❌ {name}: sha256 不一致（完整指纹，人工核对用）")
+            failures += 1
+    return failures
+
+
+def cmd_rebuild(refs: dict, args: argparse.Namespace) -> int:
+    r = refs.get(args.name)
+    if r is None:
+        print(f"❌ 清单无此条目: {args.name}")
+        return 1
+    source = Path(r["source"]).expanduser()
+    if not source.is_file():
+        sys.exit(
+            f"源录音不存在: {source}\n  清单记录的是生成该样本时的源文件路径，请把本人录音放回该位置或更新清单"
+        )
+    cmd = [
+        sys.executable,
+        str(PREPARE_REF),
+        str(source),
+        "--start",
+        str(r["start"]),
+        "--duration",
+        str(r["duration"]),
+        "--out",
+        str(VOICES_DIR / f"{args.name}.wav"),
+    ]
+    print(f">> 重建 {args.name}: {' '.join(cmd[1:])}")
+    subprocess.run(cmd, check=True)
+    return cmd_verify(refs, argparse.Namespace(name=args.name))
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description="参考音色样本可复现清单")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+    sub.add_parser("list", help="列出清单条目")
+    p = sub.add_parser("verify", help="核对盘上样本指纹")
+    p.add_argument("--name", help="只核对指定样本（默认全部）")
+    p = sub.add_parser("rebuild", help="按清单参数重建样本并复验")
+    p.add_argument("--name", required=True, help="要重建的样本名")
+    args = ap.parse_args()
+
+    refs = load_refs()
+    if args.cmd == "list":
+        cmd_list(refs)
+        return
+    failures = {"verify": cmd_verify, "rebuild": cmd_rebuild}[args.cmd](refs, args)
+    sys.exit(1 if failures else 0)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/media/pipeline/scripts/timeline.py b/media/pipeline/scripts/timeline.py
new file mode 100644
index 000000000..52391b1ad
--- /dev/null
+++ b/media/pipeline/scripts/timeline.py
@@ -0,0 +1,105 @@
+"""时间轴计算的 Python 侧实现——与各集 video/src/timing.ts:computeTimeline 同构。
+
+此前 qa_frames.py 顶部手抄了 timing.ts 的 4 个常量做镜像，唯一的守卫是 README 里
+一句散文；两处漂移会让所有抽帧时间静默错位。本模块改为直读每集
+`video/src/timing.json`（时序常数的单一事实源），与 timing.ts 同一份事实。
+
+⚠️ 与 timing.ts 的对齐契约：compute() 的游标推进逻辑必须逐行同构——
+  - 句时长 = max(1, js_round((durationSec + gap) * fps))，gap 在幕界 = 句间 + 幕间；
+    （js_round = JS Math.round 语义：.5 恒向上。内置 round() 是 banker's rounding，
+     .5 向偶数——durationSec 三位小数 × fps 落在精确 .5 时两语言分岔，从该句起
+     全片抽帧时间漂移。现有三集 manifest 实测无命中，但语义对齐须显式而非侥幸。）
+  - 总时长 = 游标 + js_round(tailSec * fps)。
+任何一侧改动须同步另一侧，并以 tests/test_timeline.py 的黄金帧号兜底。
+
+用法（被 qa_frames.py / captions.py 复用，也可独立调用对拍）：
+
+    from timeline import compute, load_constants
+    c = load_constants(Path("<工程根>"))
+    rows = compute(manifest_items, c)   # [{id, fromFrame, durationInFrames, startSec, ...}]
+"""
+
+from __future__ import annotations
+
+import json
+import math
+import sys
+from pathlib import Path
+
+
+def js_round(x: float) -> int:
+    """JS `Math.round` 语义（.5 恒向上）——非负数域与 timing.ts 逐位一致。
+
+    Python 内置 round() 是 banker's rounding（round-half-to-even）：0.5→0、10.5→10，
+    而 JS Math.round(10.5)=11。本模块输出供抽帧/字幕与 timing.ts 渲染帧号对拍，
+    两侧舍入语义必须相同，否则 .5 边界处帧号分岔。
+    """
+    return math.floor(x + 0.5)
+
+
+#: timing.json 必备字段（与 video/src/timing.ts 的消费面一致）
+REQUIRED_KEYS = (
+    "fps",
+    "sentenceGapSec",
+    "sceneGapSec",
+    "leadInSec",
+    "tailSec",
+    "sceneCrossFadeSec",
+)
+
+
+def load_constants(project_root: Path) -> dict:
+    """读 <工程>/video/src/timing.json；缺失或字段不全时给可操作退出。"""
+    path = Path(project_root) / "video" / "src" / "timing.json"
+    if not path.is_file():
+        sys.exit(
+            f"timing.json 不存在: {path}\n"
+            "  —— 时序常数单一事实源缺失，请从任一既有集复制 video/src/timing.json"
+            "（qa_frames/captions 与 timing.ts 读同一文件，不可再手抄常量）"
+        )
+    data = json.loads(path.read_text(encoding="utf-8"))
+    missing = [k for k in REQUIRED_KEYS if k not in data]
+    if missing:
+        sys.exit(f"{path} 缺少字段: {', '.join(missing)}")
+    return data
+
+
+def compute(items: list[dict], c: dict) -> list[dict]:
+    """与 timing.ts:computeTimeline 同构的时间轴展开。
+
+    items 为 manifest 形态的 [{id, scene, text, durationSec}]；返回逐句行，含
+    fromFrame / durationInFrames（全片帧位）与 startSec / spanSec（秒，供抽帧与字幕）。
+    spanSec 与 durationInFrames 一样含句间停顿（成片内该句占满的时间窗）。
+    """
+    fps = c["fps"]
+    timed: list[dict] = []
+    cursor = js_round(c["leadInSec"] * fps)
+    for i, item in enumerate(items):
+        nxt = items[i + 1] if i + 1 < len(items) else None
+        gap = (
+            c["sentenceGapSec"] + c["sceneGapSec"]
+            if nxt and nxt["scene"] != item["scene"]
+            else c["sentenceGapSec"]
+        )
+        duration_in_frames = max(1, js_round((item["durationSec"] + gap) * fps))
+        timed.append(
+            {
+                **item,
+                "fromFrame": cursor,
+                "durationInFrames": duration_in_frames,
+                "startSec": cursor / fps,
+                "spanSec": duration_in_frames / fps,
+            }
+        )
+        cursor += duration_in_frames
+    return timed
+
+
+def total_duration_in_frames(items: list[dict], c: dict) -> int:
+    rows = compute(items, c)
+    if not rows:
+        return js_round(c["tailSec"] * c["fps"])
+    last = rows[-1]
+    return (
+        last["fromFrame"] + last["durationInFrames"] + js_round(c["tailSec"] * c["fps"])
+    )
diff --git a/media/pipeline/scripts/tts.py b/media/pipeline/scripts/tts.py
index 1b65a6c5e..4418ecb89 100644
--- a/media/pipeline/scripts/tts.py
+++ b/media/pipeline/scripts/tts.py
@@ -48,6 +48,13 @@
 # --plan 排期估算用的实测常数（MPS fp32，长跑折算口径：含降频、机器争用与逐句开销）。
 # RTF_1BEAM 来自三集 596 句连续跑 8.5 小时 / 40.2 分钟纯语音；RTF_MULTIBEAM 由同句
 # 1↔3 束 A/B 实测的约 3.2 倍推得（与早期 3 束直测的 RTF 40–58 区间一致）。
+#
+# ⚠️ 2026-08-20 实测偏差（EP1 v3 两遍法，187 句）：
+#   A 遍 sunny(beams=1)：墙钟 ~1.9 h、纯语音 12.98 分 → 实测 RTF ≈ 8.8（常量 13 偏保守 1.5×）
+#   B 遍 sunny-steady(beams=3)：墙钟 1.98 h、纯语音 12.89 分 → 实测 RTF ≈ 9.2（常量 45 偏保守 4.9×）
+# 即机器空闲时 3 束的实际代价远低于「+241%」的旧口径（本次 B/A ≈ 1.04），旧数据应是
+# 在机器被占用/热节流时测得。**常量刻意不下调**：--plan 的用途是排期决策，宁可高估
+# 让人留出窗口，也不要低估导致长跑撞上其他任务；但看到估算与实测差 3–5 倍属正常。
 RTF_1BEAM = 13.0
 RTF_MULTIBEAM = 45.0
 AVG_SEC_PER_LINE = 4.2  # 三集每句音频均值
@@ -68,7 +75,7 @@
 # 风格预设 —— 数值为初值，可实测试听后微调。
 # 可选键 "beams"：预设自带的束搜索宽度（缺省 1）。束宽会改变韵律稳定度，属风格的一部分，
 # 故允许写进预设；命令行 --num-beams 显式给值时优先。注意束宽 3 使整集墙钟约 ×3.4
-#（长跑折算 RTF 13→45），若只想让关键句更稳，用 --steady 混合档而非整集升档。
+# （长跑折算 RTF 13→45），若只想让关键句更稳，用 --steady 混合档而非整集升档。
 STYLE_PRESETS: dict[str, dict] = {
     "neutral": {"label": "中性", "vec": None, "alpha": 1.0, "df": 1.0},
     "passionate": {
@@ -226,6 +233,49 @@ def steady_match(
     return any(sid.startswith(p) for p in prefixes)
 
 
+# ---------------- 音色签名护栏（防整集静默改写） ----------------
+
+#: 音频目录下的音色签名标记。逐句 `{id}.sha` 只能发现「这一句该重合成」，
+#: 发现不了「整集正被换成另一种声音」——因为换音色时每一句的摘要都合法地变了。
+#: 本标记补的正是这个缺口：它记录上次成功合成的引擎/音色/风格，
+#: 与本次不一致时硬失败，要求显式 --allow-voice-switch。不参与逐句摘要，故零缓存影响。
+ENGINE_MARKER = ".engine"
+
+#: tts_server.py 的启动命令此前有三份副本（本文件、tts_sample.py、VOICE-CLONING.md），
+#: 其中一份还留着 `<仓库路径>` 占位符——粘贴即错。收敛为唯一生成处。
+SERVER_SCRIPT = Path(__file__).resolve().parent / "tts_server.py"
+
+
+def server_launch_hint(port: int = 8766) -> str:
+    """返回可直接粘贴的 IndexTTS 服务启动命令（服务须运行在 index-tts 自己的环境里）。"""
+    return (
+        "  cd ~/tools/index-tts && uv run --frozen --with fastapi --with uvicorn \\\n"
+        "      --with soundfile --with numpy --with lameenc \\\n"
+        f"      python {SERVER_SCRIPT} --model-dir checkpoints --port {port}"
+    )
+
+
+def check_voice_marker(out_dir: Path, signature: str, allow_switch: bool) -> None:
+    """比对音色签名；不一致且未显式放行时硬失败。"""
+    marker = out_dir / ENGINE_MARKER
+    if not marker.exists():
+        return
+    previous = marker.read_text(encoding="utf-8").strip()
+    if previous == signature or allow_switch:
+        return
+    sys.exit(
+        f"音色签名与上次合成不一致，将整集改写（{len(list(out_dir.glob('*.mp3')))} 个 mp3 单槽位覆盖）：\n"
+        f"  上次: {previous}\n"
+        f"  本次: {signature}\n"
+        f"若确为有意重录，请显式加 --allow-voice-switch；否则请检查 --engine/--ref/--style 是否写错。\n"
+        f"详见 {MANUAL} §六"
+    )
+
+
+def write_voice_marker(out_dir: Path, signature: str) -> None:
+    (out_dir / ENGINE_MARKER).write_text(signature + "\n", encoding="utf-8")
+
+
 # ---------------- 引擎一：edge-tts（历史路径，保持字节级一致） ----------------
 
 
@@ -503,12 +553,24 @@ async def main() -> None:
     )
     parser.add_argument("--rate", default=DEFAULT_RATE, help="[edge] 语速（默认 +4%%）")
     parser.add_argument("--force", action="store_true", help="忽略缓存强制重合成")
+    parser.add_argument(
+        "--allow-voice-switch",
+        action="store_true",
+        help="放行音色签名变更（引擎/音色/风格换档＝整集重录，须显式确认）",
+    )
     parser.add_argument("--list-styles", action="store_true", help="列出风格预设并退出")
 
     idx = parser.add_argument_group("indextts 声音克隆")
     idx.add_argument(
         "--ref", default=None, help="[indextts] 参考音色样本路径（建议 5–15s 干净人声）"
     )
+    idx.add_argument(
+        "--expect-ref-sha1",
+        default=None,
+        metavar="12HEX",
+        help="[indextts] 期望的参考样本 sha1 前 12 位，不符即硬失败——pipeline.py 从"
+        "各集 pipeline.toml 自动带上，防「换样本静默重录整集」（指纹清单见 voices/refs.toml）",
+    )
     idx.add_argument(
         "--server", default="http://127.0.0.1:8766", help="[indextts] 服务地址"
     )
@@ -605,33 +667,49 @@ async def main() -> None:
     if args.engine == "edge":
         # --plan 语义是「只看不跑」，而 edge 无束宽/无估时口径。若沿用「提示后照跑」的处理，
         # 漏写 --engine indextts 时会静默全量合成，把整集克隆音频改写成 edge 预置音色
-        #（两引擎摘要必然不同，且 {id}.mp3 单槽位），故此处硬失败而非忽略。
+        # （两引擎摘要必然不同，且 {id}.mp3 单槽位），故此处硬失败而非忽略。
         if args.plan:
             parser.error(
                 "--plan 仅对 --engine indextts 生效（是否漏写 --engine indextts？）"
             )
-        ignored = [
+        # 克隆专属参数分两类处置。**带值参数硬失败**：漏写 --engine indextts 的典型手型
+        # 就是「照抄文档打了 --ref/--style 却丢了 --engine」，而 {id}.mp3 是单槽位、
+        # 两引擎摘要必然不同 ⇒ 照跑就会把整集克隆音频静默改写成 edge 预置音色。
+        # 上面 --plan 已按此论证硬化，合成路径同理（否则只硬化了「看」、没硬化「跑」）。
+        clone_only = [
             flag
             for flag, val in {
                 "--ref": args.ref,
                 "--emo-vector": args.emo_vector,
                 "--emo-ref": args.emo_ref,
                 "--emo-text": args.emo_text,
-                "--emo-alpha": args.emo_alpha,
-                "--duration-factor": args.duration_factor,
+                "--emo-alpha": args.emo_alpha is not None,
+                "--duration-factor": args.duration_factor is not None,
                 "--num-beams": args.num_beams is not None,
                 "--steady": args.steady,
-                "--steady-beams": args.steady_beams != 3,
-                "--server": args.server != "http://127.0.0.1:8766",
                 "--style": args.style != "neutral",
                 "--lang": args.lang != "ZH",
+            }.items()
+            if val
+        ]
+        if clone_only:
+            parser.error(
+                f"以下参数仅对 --engine indextts 生效: {' '.join(clone_only)}"
+                "（是否漏写 --engine indextts？若确实要用 edge 预置音色，请去掉这些参数）"
+            )
+        # 无副作用的旁路参数：给不到默认值也不会改变输出，只提示不失败
+        benign = [
+            flag
+            for flag, val in {
+                "--steady-beams": args.steady_beams != 3,
+                "--server": args.server != "http://127.0.0.1:8766",
                 "--engine-tag": args.engine_tag != "indextts",
             }.items()
             if val
         ]
-        if ignored:
+        if benign:
             print(
-                f"提示：以下参数仅对 --engine indextts 生效，已忽略: {' '.join(ignored)}",
+                f"提示：以下参数仅对 --engine indextts 生效，已忽略: {' '.join(benign)}",
                 file=sys.stderr,
             )
 
@@ -644,6 +722,8 @@ async def main() -> None:
     out_dir.mkdir(parents=True, exist_ok=True)
 
     if args.engine == "edge":
+        signature = f"edge|{args.voice}|{args.rate}"
+        check_voice_marker(out_dir, signature, args.allow_voice_switch)
         sem = asyncio.Semaphore(CONCURRENCY_EDGE)
         results = await asyncio.gather(
             *(
@@ -705,6 +785,13 @@ async def main() -> None:
             # 情感样本按内容入摘要：换情感录音必须失效缓存（与 ref 同口径）
             emo_ref_sha1 = hashlib.sha1(p.read_bytes()).hexdigest()[:12]
         ref_sha1 = hashlib.sha1(ref_path.read_bytes()).hexdigest()[:12]
+        # 指纹硬校验：样本即音色。换样本 = 整集换音色，必须在长跑开始前失败
+        if args.expect_ref_sha1 and args.expect_ref_sha1 != ref_sha1:
+            parser.error(
+                f"参考样本指纹不符：期望 {args.expect_ref_sha1}，实得 {ref_sha1}"
+                f"（{ref_path}）——源录音或裁剪参数已变。"
+                f"勿在未核验音色上跑长合成；指纹清单见 media/pipeline/voices/refs.toml"
+            )
 
         # 混合档：解析选择器并逐句定束宽（此处即失败，避免典型的「id 拼错→静默全按低束宽跑完」）
         beams_of: dict[str, int] = dict.fromkeys((i["id"] for i in items), beams)
@@ -727,6 +814,10 @@ async def main() -> None:
                 if steady_match(i, sids, scenes, prefixes):
                     beams_of[i["id"]] = args.steady_beams
 
+        signature = f"indextts|{args.engine_tag}|{style_name}|{ref_sha1}"
+        # 在 --plan 之前检查：排期正是发现「这次长跑将整集换音色」的最佳时机
+        check_voice_marker(out_dir, signature, args.allow_voice_switch)
+
         if args.plan:  # 计划模式：纯本地计算，不连服务
             print(
                 f">> 计划：{root.name} · 风格 {style_name} · alpha {alpha:g} · 语速 {df:g}"
@@ -784,11 +875,7 @@ async def main() -> None:
                 raise RuntimeError(f"health.ok=false: {health}")
         except Exception as e:  # noqa: BLE001 - 服务未启动给出可操作指引
             print(
-                f"IndexTTS 服务不可用（{e}）。请先启动：\n"
-                f"  cd ~/tools/index-tts && uv run --frozen --with fastapi --with uvicorn --with soundfile \\\n"
-                f"      --with numpy --with lameenc python <仓库路径>/media/pipeline/scripts/tts_server.py \\\n"
-                f"      --model-dir checkpoints --port 8766\n"
-                f"详见 {MANUAL} §二",
+                f"IndexTTS 服务不可用（{e}）。请先启动：\n{server_launch_hint()}\n详见 {MANUAL} §二",
                 file=sys.stderr,
             )
             sys.exit(1)
@@ -834,6 +921,7 @@ async def main() -> None:
     manifest_path.write_text(
         json.dumps(results, ensure_ascii=False, indent=1) + "\n", encoding="utf-8"
     )
+    write_voice_marker(out_dir, signature)  # 成功收尾才落签名，中途失败不改变基线
     total = sum(r["durationSec"] for r in results)
     print(f"合成 {len(results)} 句，纯语音总时长 {total / 60:.2f} 分钟")
     if args.engine == "indextts" and args.steady:  # 混合档：回执两档各多少句，便于对账
diff --git a/media/pipeline/scripts/tts_sample.py b/media/pipeline/scripts/tts_sample.py
index ae1d2198e..9a2837ae2 100644
--- a/media/pipeline/scripts/tts_sample.py
+++ b/media/pipeline/scripts/tts_sample.py
@@ -40,10 +40,10 @@
     http_synthesize,
     mp3_duration,
     resolve_style,
+    server_launch_hint,
     tts_text,
 )
 
-SERVER_SCRIPT = Path(__file__).resolve().parent / "tts_server.py"
 # parents: [0]=scripts [1]=pipeline [2]=media [3]=仓库根（与 prepare_ref.py 的 parents[1] 同惯例）
 DEFAULT_OUT_DIR = Path(__file__).resolve().parents[3] / ".temp" / "voice-samples"
 DEFAULT_TEXT = "自进化编码智能体的核心不是写代码，而是让 AI 学会修改自己写代码的方式。"
@@ -94,11 +94,7 @@ def check_server(
             raise RuntimeError(f"health.ok=false: {health}")
     except Exception as e:  # noqa: BLE001 - 任何不可达都归一为可操作指引
         sys.exit(
-            f"IndexTTS 服务不可用（{e}）。请先启动：\n"
-            f"  cd ~/tools/index-tts && uv run --frozen --with fastapi --with uvicorn \\\n"
-            f"      --with soundfile --with numpy --with lameenc \\\n"
-            f"      python {SERVER_SCRIPT} --model-dir checkpoints --port 8766\n"
-            f"详见 {MANUAL} §2.3"
+            f"IndexTTS 服务不可用（{e}）。请先启动：\n{server_launch_hint()}\n详见 {MANUAL} §2.3"
         )
     print(
         f">> 服务就绪：IndexTTS-{health.get('version')} device={health.get('device')} "
@@ -155,8 +151,7 @@ def synthesize_one(
         wall = time.perf_counter() - t0
         if fmt != "mp3":
             sys.exit(
-                f"[{name}] 服务端 MP3 编码器不可用（X-Audio-Format={fmt}）—— "
-                f"按 {MANUAL} §七 带 --with lameenc 重启服务"
+                f"[{name}] 服务端 MP3 编码器不可用（X-Audio-Format={fmt}）—— 按 {MANUAL} §七 带 --with lameenc 重启服务"
             )
         if not audio:
             last_err = RuntimeError("空音频响应")
@@ -270,6 +265,11 @@ def main() -> None:
         help=f"产物目录（默认 {DEFAULT_OUT_DIR}，已被 .gitignore 忽略）",
     )
     parser.add_argument("--play", action="store_true", help="合成后用 afplay 顺序试听")
+    parser.add_argument(
+        "--cleanup",
+        action="store_true",
+        help="试听结束后立即删除产物目录（小样含本人音色，属生物特征信息）",
+    )
     parser.add_argument(
         "--dry-run", action="store_true", help="只解析并打印参数，不连服务、不合成"
     )
@@ -346,7 +346,7 @@ def main() -> None:
         jobs = build_jobs(args)
     except ValueError as e:  # parse_emo_vector 的键名/权重错误
         parser.error(str(e))
-    for name, vec, alpha, df, _beams in jobs:
+    for name, vec, alpha, _df, _beams in jobs:
         if (
             vec is not None and sum(vec) * alpha > 0.8
         ):  # 与服务端同口径：alpha 缩放后校验有效和
@@ -415,7 +415,7 @@ def main() -> None:
     if args.play:
         play(results)
     # raw / emoref / emotext 都是本脚本内部的档名，并非 tts.py `--style` 的合法取值
-    #（其 choices=list(STYLE_PRESETS)），故须回显各自的开关，否则这条命令照抄即 argparse 报错
+    # （其 choices=list(STYLE_PRESETS)），故须回显各自的开关，否则这条命令照抄即 argparse 报错
     if len(results) == 1 and results[0]["style"] == "raw":
         chosen = f'--emo-vector "{args.emo_vector}"'
     elif args.emo_ref:
@@ -434,9 +434,16 @@ def main() -> None:
     print(
         f"\n下一步 · 选定风格后全量合成一集：\n"
         f"  cd media/<工程> && uv run --no-project --with mutagen scripts/tts.py \\\n"
-        f"      --engine indextts --ref {ref} {chosen}\n"
-        f"清理 · 小样含本人音色（生物特征信息），试听后请删除：rm -rf {out_dir}"
+        f"      --engine indextts --ref {ref} {chosen}"
     )
+    if args.cleanup:
+        shutil.rmtree(out_dir, ignore_errors=True)
+        print(f"清理 · 已删除产物目录（生物特征信息）：{out_dir}")
+    else:
+        print(
+            f"清理 · 小样含本人音色（生物特征信息），试听后请删除：rm -rf {out_dir}\n"
+            f"       （下次可直接加 --cleanup 让脚本自动删除）"
+        )
 
 
 if __name__ == "__main__":
diff --git a/media/pipeline/skills/03-narration.md b/media/pipeline/skills/03-narration.md
index 0e94bc7ee..fdc210fad 100644
--- a/media/pipeline/skills/03-narration.md
+++ b/media/pipeline/skills/03-narration.md
@@ -9,7 +9,7 @@
 
 > **格式约定**：`- [句id] 口播文本`——每行一句，一句 = 一条字幕 = 一段配音。
 > `>` 引用块为画面备注，不进入配音。英文方法名原则上不口播，做成画面角标。
-> 事实源：[../research/paper-notes.md](../research/paper-notes.md)
+> 事实源：`media/<slug>-video/research/paper-notes.md`（各集工程内相对路径引用）
 
 ## P0 幕标题
 
@@ -40,3 +40,5 @@
 - [ ] 每个断言 grep paper-notes 可命中；
 - [ ] 角标（英文方法名）已随句标注；
 - [ ] 估算时长（280 字/分）落在硬约束区间内。
+
+- **系列纪律**：口播文本严禁出现其他集标题、集数序号或「上一集/上期/第 N 集」等顺序词——顺序只存在于视觉层与 `media/series.json`，据此保证发布顺序变更的 TTS 代价为零（「下期再见」一类顺序无关的收尾语不受此限；校验器 `media/pipeline/scripts/check_series.py`）。
diff --git a/media/pipeline/skills/06-remotion-implementation.md b/media/pipeline/skills/06-remotion-implementation.md
index cfda738d9..6b6a2a501 100644
--- a/media/pipeline/skills/06-remotion-implementation.md
+++ b/media/pipeline/skills/06-remotion-implementation.md
@@ -7,18 +7,29 @@
 
 - `script/storyboard.md`（分镜规格：镜号 ↔ 句 id 区间 ↔ 画面 ↔ 动效）
 - `video/public/audio/manifest.json`（TTS 产物：每句实测时长）
-- 上一集工程的 `video/` 骨架（脚手架来源）
+- 任一既有集工程的 `video/` 骨架（脚手架来源；与发布顺序无关）
 
 ## 骨架复制适配策略
 
-从上一集 `cp -r` 复制后，**逐字节保留**（跨集零差异，勿改）：
+从既有集工程 `cp -r` 复制后，冻结清单分两档：
 
-- `src/timing.ts`（computeTimeline + beatWindow；常量与 `qa_frames.py` 镜像对齐——改常量必须双改）
+**A 档 · 逐字节保留**（跨集零差异，改任何一处须三集同步并验 md5 唯一）：
+
+- `src/timing.ts`（computeTimeline + beatWindow + SCENE_FADE_FRAMES 导出；常数读同目录 `timing.json`）
 - `src/types.ts` / `src/Root.tsx` / `src/index.ts`
-- `src/components/Subtitle.tsx`（CJK 宽度估算防溢出）/ `NarrationAudio.tsx` / `cards.tsx`
+- `src/components/NarrationAudio.tsx`（@remotion/media 的 `<Audio>`，from/durationInFrames 原生定位 + premountFor）/ `Subtitle.tsx`（fitText 真实测量）/ `SceneFade.tsx`（幕间呼吸淡入淡出）/ `cards.tsx`
 - `scripts/*.py` 薄包装、`remotion.config.ts`、`.npmrc`、`tsconfig.json`
 
-**每集改写**：`package.json`（name）、`src/design/theme.ts`（本集色板）、`src/scenes/*`（全部重写）、`src/Main.tsx`（仅 import 与 SCENE_COMPONENTS 注册表）。
+**B 档 · 默认逐字节相同、允许本集覆写**：`src/timing.json`（时序常数 SSOT——timing.ts 与 Python 侧 qa_frames/captions 共读同一文件，**改常量只改此处**，勿再双改代码）。
+
+**每集改写**：`package.json`（name）、`src/design/theme.ts`（本集色板）、`src/scenes/*`（全部重写）、`src/Main.tsx`（仅 import 与 SCENE_COMPONENTS 注册表）、`pipeline.toml`（本集配音/渲染参数）。
+
+## 事实条（防重复论证）
+
+- `premountFor` 在**渲染期自动关闭**（active 含 `!env.isRendering`）——只优化 Studio 拖拽与 Player 预览；渲染侧收益是 Mediabunny 抽轨与时间轴同步，不是渲染速度。
+- 幕间转场**不用** `@remotion/transitions` 的 TransitionSeries：其总时长 = Σ序列 − Σ转场，会把视觉层整体左移而旁白（manifest 帧号绝对定位的独立层）不动 → 逐幕递增失同步。用 `SceneFade`（只花幕间既有静默，from/总时长零改动；不变式 `2×sceneCrossFadeSec ≤ sentenceGap+sceneGap` 由 check_script.py 强制）。
+- 字体可复现性：三集用 macOS 系统字体栈（PingFang SC/Songti SC/SF Mono），未内嵌 CJK 字体——**渲染仅限 macOS 主机**。两个重启触发器：渲染迁 Linux/CI；Remotion 5.0 把 fitText 的 validateFontIsLoaded 默认翻 true（届时须内嵌子集字体，注意 pre-commit --maxkb=1024）。
+- 路径描画优先 `@remotion/paths`（evolvePath/getPointAtLength）——它是「pathLength 与 px 版 strokeDasharray 互斥」红线的官方正解；线型样式（虚线/点线）另置静态叠加路径，勿与描画动画挤在同一元素。
 
 复用边界的原则（见 [../README.md](../README.md) 第四节）：Python 脚本集中 SSOT；**Remotion 原语复制适配不共享**——共享 TS 包会把一集的视觉改动泄漏进其他集。
 
diff --git a/media/pipeline/skills/07-tts-voice.md b/media/pipeline/skills/07-tts-voice.md
new file mode 100644
index 000000000..02edbf783
--- /dev/null
+++ b/media/pipeline/skills/07-tts-voice.md
@@ -0,0 +1,26 @@
+# Stage ⑥ TTS 配音：声音克隆决策树（skill 规格 · 07）
+
+> 目标读者：执行配音阶段的代理/操作者。**参数与实测数据一律以 [VOICE-CLONING.md](../VOICE-CLONING.md) §三–§六为准（链接非复制）**；本文件只承载操作顺序与决策点。
+
+## 决策树（按序过闸，任何一闸不过不进长跑）
+
+1. **样本就位？** `uv run --no-project media/pipeline/scripts/refs.py list` → 缺失则 `refs.py rebuild --name <样本>`（源录音是本人私有文件，路径记录在 `voices/refs.toml`）。
+2. **指纹一致？** `refs.py verify --name <样本>` 必须全绿——sha1 与清单不符说明源文件/裁剪参数变了，**勿在未核验音色上烧 10 小时**；新样本须先过第 4 步试听再回填清单。
+3. **风格定档？** 首次/换风格必过小样 A/B：`tts_sample.py --ref <样本> --all-styles --play`；再用**领航片段**（本集最难的 6–8 句：长分句/枚举清单/带小数点数字）在该风格下整句合成试听。听完 `--cleanup` 或 `pipeline.py clean-samples`（生物特征）。
+4. **排期对账？** `pipeline.py tts --plan`（纯本地）：待合成句数 × 束宽档 + 墙钟估算。ETA 与预期差 >15% 先查机器负载。
+5. **音色签名护栏**：与上次合成不一致会被 `.engine` 标记硬拦（显式 `--allow-voice-switch` 才放行）——这正是防「README 旧命令静默重录整集」的机制。
+
+## 两遍法（长片的既定工作法）
+
+草稿遍 `--style sunny`（快 ≈3.4×）拿真 manifest 校时间轴与分镜 → 定稿遍回到成片档（`sunny-steady`，beams=3）。**改稿只废改动句；换档全量重合成**（摘要含 style/ref/束宽，见 VOICE-CLONING §六）。B 遍必须在文稿字节冻结后启动。
+
+## 调用形态
+
+- 编排入口（参数读自各集 `pipeline.toml`）：`uv run --no-project media/pipeline/scripts/pipeline.py --project media/<slug>-video tts [--plan|--style sunny]`
+- 直接薄包装（工程内）：`uv run --no-project --with mutagen scripts/tts.py --engine indextts …`（须带 `--expect-ref-sha1`，编排入口会自动带上）
+- 服务端启动命令由 `tts.py`/`tts_sample.py` 在不可达时自动打印（可直接粘贴），手册见 [VOICE-CLONING.md §二](../VOICE-CLONING.md)
+
+## 完成门（交给 Stage ⑧ 前）
+
+- manifest 句数 = narration 句数；`pipeline.py check` 的实测时长口径落在预算窗内；
+- sidecar `{id}.sha` 逐句齐备（断点续跑的依据）；`.engine` 标记已更新。
diff --git a/media/pipeline/skills/08-render-qa.md b/media/pipeline/skills/08-render-qa.md
new file mode 100644
index 000000000..7491b6836
--- /dev/null
+++ b/media/pipeline/skills/08-render-qa.md
@@ -0,0 +1,45 @@
+# Stage ⑧ 草渲 + 抽帧 QA（skill 规格 · 08）
+
+> 草渲的意义：半分辨率快速出片，把「时长/分镜/画面」问题在终渲前暴露。渲染缺陷的**七条红线**沉淀在 [06-remotion-implementation.md](./06-remotion-implementation.md)（SSOT，此处不复制）；本文件覆盖抽帧与自动体检的操作契约。
+
+## 命令闭环
+
+```bash
+# 草渲（0.5x，jpeg 60——参数已固化在 remotion.config.ts + pipeline.toml）
+uv run --no-project media/pipeline/scripts/pipeline.py --project media/<slug>-video render
+
+# 抽帧三选一：幕抽样 / 指定句 / 末 N 句（尾幕渐黑缺陷的必查项）
+# ⚠️ 草渲 --check 须带 --scale 0.5：字幕带/亮块间隔按全分辨率像素常数计算，不折算则判据双向失真
+# ⚠️ 视频路径按 CWD 解析（非 --project 相对）——从仓库根调用须写 media/<slug>-video/out/draft.mp4
+uv run --no-project --with pillow --with numpy media/pipeline/scripts/qa_frames.py \
+    --project media/<slug>-video media/<slug>-video/out/draft.mp4 --scene P2 [--check --scale 0.5]
+uv run --no-project --with pillow --with numpy media/pipeline/scripts/qa_frames.py \
+    --project media/<slug>-video media/<slug>-video/out/draft.mp4 p6-11 p6-13b --check --scale 0.5
+uv run --no-project --with pillow --with numpy media/pipeline/scripts/qa_frames.py \
+    --project media/<slug>-video media/<slug>-video/out/draft.mp4 --last-n 6 --check --scale 0.5
+
+# 主题对比度（零依赖，不需视频；新配色/改 theme.ts 后必跑）
+uv run --no-project media/pipeline/scripts/qa_frames.py --project media/<slug>-video --check-theme
+```
+
+## 自动体检判据与处置
+
+| 判据 | 级别 | 处置 |
+|---|---|---|
+| 黑帧/早渐黑（均值 <0.02；末 beat 且分镜标「渐黑」豁免） | FAIL | 查尾幕渐黑是否从**末 beat** 而非末句推导（skills/06 红线 4）；查 SceneFade 末幕是否误开淡出 |
+| 字幕带侵入（字幕框 x 区间外有独立亮块） | WARN | 角标/图形挪出 bottom≥160px 安全区（角标一律绝对定位并写死 `bottom ≥ 150`） |
+| 冻帧（相邻采样帧 16×16 指纹相同） | WARN | 查 beat 窗口是否错位/句子未被分镜覆盖（`check_script.py --check-scenes`） |
+| 字幕缺失（字幕带无文字亮度像素） | WARN | 查该句 Subtitle 是否被遮挡或文本为空 |
+| 主题对比度 <4.5:1 | FAIL | 换色或加深；概念色清单见 skills/06 视觉契约 |
+
+**注意**：`--offset` 仅在草渲与终渲时间基准不一致时使用；每次重合成后**所有** beat 时间轴位移，抽帧样点必须从新 manifest 重推（工具自动做，但不要复用旧帧目录的旧结论）。
+
+## 人工目检清单（自动体检之外的残余）
+
+1. 色彩语义遵守本集契约（每个概念色的指代不串）；
+2. 每个 beat 画面与分镜「画面/动效」列语义一致；
+3. 金句卡排版（衬线体/居中/角标出处）。
+
+## 修复回路
+
+问题 → 改场景组件（或分镜/文稿）→ `tsc --noEmit` → 重草渲 → 复抽帧。**禁止跳过复检直接终渲**。
diff --git a/media/pipeline/skills/09-final-render.md b/media/pipeline/skills/09-final-render.md
new file mode 100644
index 000000000..baabdec9c
--- /dev/null
+++ b/media/pipeline/skills/09-final-render.md
@@ -0,0 +1,37 @@
+# Stage ⑨ 终渲与交付（skill 规格 · 09）
+
+> 前置：Stage ⑧ 的自动体检零 FAIL 且人工目检通过；文稿与音频已冻结（B 遍完成）。
+
+## 终渲
+
+```bash
+cd media/<slug>-video/video
+# 终渲（codec/crf/pixel-format/audio 已固化在 remotion.config.ts）
+./node_modules/.bin/remotion render Main ../out/final.mp4
+```
+
+**关于并发**：并发度是机器属性、不进共享配置（见 §渲染硬化）。但 `remotion benchmark`
+**对本类长片不实用**——它要按不同并发把整片渲多轮，25000 帧规模下 20 分钟不出结果
+（2026-08-20 实测放弃）。实践口径：直接用 Remotion 默认并发（它已按 CPU 核数自适应）；
+仅当终渲耗时明显异常时，才对**单幕**做 `--frames=<区间>` 的小样对比来选 `--concurrency=N`。
+
+渲染主机约束：**macOS + PingFang SC/Songti SC/SF Mono 系统字体**（三集未内嵌 CJK 字体，Linux/CI 渲染不在支持范围；重启触发器见 pipeline/README「字体可复现性」——渲染迁 Linux/CI，或 Remotion 5.0 将 validateFontIsLoaded 默认翻 true 时必须内嵌子集字体）。
+
+## 交付件清单
+
+```bash
+# 字幕（B 站/YouTube 上传件；cue 终点不含句间停顿——外挂字幕静默期不留字）
+uv run --no-project media/pipeline/scripts/captions.py --project media/<slug>-video
+```
+
+- [ ] `out/final.mp4`（1080p30，h264/aac192K；`remotion ffmpeg -i` 核流摘要）
+- [ ] `out/captions.srt` + `out/captions.vtt`
+- [ ] 封面帧（可从 `qa_frames.py` 挑一张标题卡帧，或 `remotion still` 单渲）
+- [ ] 全片逐幕抽帧复检 + `--last-n 6 --check`（时长在 B 遍后又位移过，勿复用 A 遍结论）
+- [ ] `pipeline.py check` 实测口径在预算窗内
+
+## 平台合规（发布前自查）
+
+- 合成语音标注：B 站/YouTube 对 AI 合成语音有披露要求，按平台当期规则标注；
+- 许可：Remotion（>3 人公司需商业授权）；IndexTTS-2.5（bilibili 模型许可，个人/研究可用，商用联系 indexspeech@bilibili.com）——详见 [pipeline/README §八](../README.md)；
+- 声音克隆仅为本人自愿克隆；克隆他人声音须书面同意（[VOICE-CLONING.md §八](../VOICE-CLONING.md)）。
diff --git a/media/pipeline/tests/conftest.py b/media/pipeline/tests/conftest.py
new file mode 100644
index 000000000..26dffed92
--- /dev/null
+++ b/media/pipeline/tests/conftest.py
@@ -0,0 +1,51 @@
+"""media/pipeline 测试公共夹具。
+
+落位说明：仓库根无 tests/；apps/negentropy 的 tests/conftest.py 是 session 级
+autouse 建 Postgres 夹具，pytest 只加载 rootdir→测试文件路径上的 conftest，
+本目录不在那条祖先链上——结构上不可能被拉起 DB。全部用例无网络、无 TTS、
+无 ffmpeg、无 Postgres，总时长秒级。
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import pytest
+
+PIPELINE_SCRIPTS = Path(__file__).resolve().parents[1] / "scripts"
+FIXTURES = Path(__file__).resolve().parent / "fixtures"
+sys.path.insert(0, str(PIPELINE_SCRIPTS))
+
+
+@pytest.fixture()
+def constants() -> dict:
+    return json.loads((FIXTURES / "timing.json").read_text(encoding="utf-8"))
+
+
+@pytest.fixture()
+def manifest_items() -> list[dict]:
+    return json.loads((FIXTURES / "manifest.json").read_text(encoding="utf-8"))
+
+
+@pytest.fixture()
+def project(tmp_path: Path) -> Path:
+    """最小工程骨架：fixtures 内容铺进临时目录（check/captions 等按真实布局消费）。"""
+    root = tmp_path / "fixture-video"
+    (root / "script").mkdir(parents=True)
+    (root / "video" / "public" / "audio").mkdir(parents=True)
+    (root / "video" / "src").mkdir(parents=True)
+    for name in ("narration.md", "narration.json", "storyboard.md"):
+        (root / "script" / name).write_bytes((FIXTURES / name).read_bytes())
+    (root / "video" / "src" / "timing.json").write_bytes(
+        (FIXTURES / "timing.json").read_bytes()
+    )
+    (root / "video" / "src" / "design").mkdir()
+    (root / "video" / "src" / "design" / "theme.ts").write_bytes(
+        (FIXTURES / "theme.ts").read_bytes()
+    )
+    (root / "video" / "public" / "audio" / "manifest.json").write_bytes(
+        (FIXTURES / "manifest.json").read_bytes()
+    )
+    return root
diff --git a/media/pipeline/tests/fixtures/manifest.json b/media/pipeline/tests/fixtures/manifest.json
new file mode 100644
index 000000000..7e21111e6
--- /dev/null
+++ b/media/pipeline/tests/fixtures/manifest.json
@@ -0,0 +1,6 @@
+[
+  {"id": "p0-01", "scene": "P0", "text": "第一幕第一句。", "durationSec": 3.10},
+  {"id": "p0-02", "scene": "P0", "text": "第一幕第二句。", "durationSec": 2.05},
+  {"id": "p1-01", "scene": "P1", "text": "第二幕第一句。", "durationSec": 4.77},
+  {"id": "p1-02", "scene": "P1", "text": "第二幕第二句，稍长一些用来测预算。", "durationSec": 1.02}
+]
diff --git a/media/pipeline/tests/fixtures/narration.json b/media/pipeline/tests/fixtures/narration.json
new file mode 100644
index 000000000..4ecfa20d5
--- /dev/null
+++ b/media/pipeline/tests/fixtures/narration.json
@@ -0,0 +1,6 @@
+[
+  {"id": "p0-01", "scene": "P0", "text": "第一幕第一句。"},
+  {"id": "p0-02", "scene": "P0", "text": "第一幕第二句。"},
+  {"id": "p1-01", "scene": "P1", "text": "第二幕第一句。"},
+  {"id": "p1-02", "scene": "P1", "text": "第二幕第二句，稍长一些用来测预算。"}
+]
diff --git a/media/pipeline/tests/fixtures/narration.md b/media/pipeline/tests/fixtures/narration.md
new file mode 100644
index 000000000..005b4462f
--- /dev/null
+++ b/media/pipeline/tests/fixtures/narration.md
@@ -0,0 +1,15 @@
+# 逐字稿：测试夹具（v1）
+
+> 格式约定：`- [句id] 文本`。
+
+## P0 冷开场
+
+> 画面：测试。
+
+- [p0-01] 第一幕第一句。
+- [p0-02] 第一幕第二句。
+
+## P1 展开
+
+- [p1-01] 第二幕第一句。
+- [p1-02] 第二幕第二句，稍长一些用来测预算。
diff --git a/media/pipeline/tests/fixtures/storyboard.md b/media/pipeline/tests/fixtures/storyboard.md
new file mode 100644
index 000000000..a34a75d81
--- /dev/null
+++ b/media/pipeline/tests/fixtures/storyboard.md
@@ -0,0 +1,13 @@
+# 分镜表：测试夹具
+
+## P0 冷开场
+
+| 镜 | 句区间 | 画面 | 动效 |
+|---|---|---|---|
+| 0-A 全覆盖 | p0-01..02 | 第一镜 | 淡入 |
+
+## P1 展开
+
+| 镜 | 句区间 | 画面 | 动效 |
+|---|---|---|---|
+| 1-A 全覆盖 | p1-01..02 | 第二镜 | 淡出 |
diff --git a/media/pipeline/tests/fixtures/theme.ts b/media/pipeline/tests/fixtures/theme.ts
new file mode 100644
index 000000000..0edc8473c
--- /dev/null
+++ b/media/pipeline/tests/fixtures/theme.ts
@@ -0,0 +1,26 @@
+/** 全片视觉规范（见 script/planning.md 与 storyboard.md）
+ *  本集三色语义契约：
+ *  金 = 经验流（trace → 可用经验 z，全片主色）
+ *  青 = Harness 运行时（快时标外部更新面）
+ *  紫 = 参数内化（慢时标权重巩固） */
+export const theme = {
+  bg: '#0E1116',
+  panel: '#171C26',
+  panelBorder: '#2A3242',
+  text: '#F2F5FA',
+  dim: '#9AA7B8',
+  /** 金 = 经验流（trace→z，全片主线） */
+  exp: '#F5C542',
+  expDeep: '#5c4a1a',
+  /** 青 = Harness 运行时（快时标外部更新） */
+  harness: '#2DD4BF',
+  harnessDeep: '#134a44',
+  /** 紫 = 参数内化（慢时标巩固进模型权重） */
+  params: '#B78CFF',
+  paramsDeep: '#3d2a5c',
+  danger: '#FF5C5C',
+  ok: '#7ED321',
+  serif: "'Songti SC', 'STSong', 'Noto Serif SC', serif",
+  sans: "'PingFang SC', 'Hiragino Sans GB', 'Noto Sans SC', sans-serif",
+  mono: "'SF Mono', 'Menlo', 'JetBrains Mono', monospace",
+} as const;
diff --git a/media/pipeline/tests/fixtures/timing.json b/media/pipeline/tests/fixtures/timing.json
new file mode 100644
index 000000000..1090a53bf
--- /dev/null
+++ b/media/pipeline/tests/fixtures/timing.json
@@ -0,0 +1,8 @@
+{
+  "fps": 30,
+  "sentenceGapSec": 0.32,
+  "sceneGapSec": 0.9,
+  "leadInSec": 0.6,
+  "tailSec": 2.0,
+  "sceneCrossFadeSec": 0.4
+}
diff --git a/media/pipeline/tests/test_build_narration.py b/media/pipeline/tests/test_build_narration.py
new file mode 100644
index 000000000..00540169e
--- /dev/null
+++ b/media/pipeline/tests/test_build_narration.py
@@ -0,0 +1,70 @@
+"""build_narration 解析/校验分支（经 subprocess 走真实 CLI 入口）。"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+SCRIPT = Path(__file__).resolve().parents[1] / "scripts" / "build_narration.py"
+
+
+def run_build(root: Path) -> subprocess.CompletedProcess:
+    return subprocess.run(
+        [sys.executable, str(SCRIPT), "--project", str(root)],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+
+def make_project(tmp_path: Path, md: str) -> Path:
+    root = tmp_path / "ep"
+    (root / "script").mkdir(parents=True)
+    (root / "script" / "narration.md").write_text(md, encoding="utf-8")
+    return root
+
+
+def test_happy_path_and_golden_json(tmp_path):
+    root = make_project(
+        tmp_path,
+        "## P0 开场\n\n- [p0-01] 甲句。\n> 备注不入稿\n- [p0-02] 乙句。\n\n## 不相关标题\n",
+    )
+    r = run_build(root)
+    assert r.returncode == 0, r.stderr
+    data = json.loads((root / "script" / "narration.json").read_text(encoding="utf-8"))
+    assert data == [
+        {"id": "p0-01", "scene": "P0", "text": "甲句。"},
+        {"id": "p0-02", "scene": "P0", "text": "乙句。"},
+    ]
+    assert "不相关标题" not in json.dumps(data, ensure_ascii=False)
+
+
+def test_missing_file_actionable_exit(tmp_path):
+    root = tmp_path / "empty"
+    (root / "script").mkdir(parents=True)
+    r = run_build(root)
+    assert r.returncode != 0
+    assert "narration.md 不存在" in r.stderr or "narration.md 不存在" in r.stdout
+
+
+def test_duplicate_id(tmp_path):
+    root = make_project(tmp_path, "## P0\n- [p0-01] 甲。\n- [p0-01] 乙。\n")
+    r = run_build(root)
+    assert r.returncode != 0
+    assert "重复句 id" in (r.stderr + r.stdout)
+
+
+def test_scene_prefix_mismatch_names_scene(tmp_path):
+    root = make_project(tmp_path, "## P1\n- [p1-01] 对。\n- [p0-09] 错。\n")
+    r = run_build(root)
+    assert r.returncode != 0
+    assert "p0-09" in (r.stderr + r.stdout) and "P1" in (r.stderr + r.stdout)
+
+
+def test_sentence_before_any_scene_heading(tmp_path):
+    root = make_project(tmp_path, "- [p0-01] 无幕句。\n\n## P0\n- [p0-02] 有幕句。\n")
+    r = run_build(root)
+    assert r.returncode != 0
+    assert "## Pn" in (r.stderr + r.stdout)  # 报真正原因而非「与所在幕  不一致」
diff --git a/media/pipeline/tests/test_captions.py b/media/pipeline/tests/test_captions.py
new file mode 100644
index 000000000..342ceccbd
--- /dev/null
+++ b/media/pipeline/tests/test_captions.py
@@ -0,0 +1,46 @@
+"""captions 的时间戳与格式（srt/vtt 字节级黄金）。"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "scripts"))
+from captions import build_cues, fmt_ts_srt, fmt_ts_vtt, render_srt, render_vtt  # noqa: E402
+
+C = {
+    "fps": 30,
+    "sentenceGapSec": 0.32,
+    "sceneGapSec": 0.9,
+    "leadInSec": 0.6,
+    "tailSec": 2.0,
+}
+
+
+def test_timestamp_format():
+    assert fmt_ts_srt(3661.5) == "01:01:01,500"
+    assert fmt_ts_vtt(3661.5) == "01:01:01.500"
+
+
+def test_cue_end_excludes_gap():
+    """外挂字幕 cue 终点 = 起点 + durationSec（不含句间停顿）——与烧录字幕的有意分歧。"""
+    items = [
+        {"id": "p0-01", "scene": "P0", "text": "甲。", "durationSec": 3.0},
+        {"id": "p0-02", "scene": "P0", "text": "乙。", "durationSec": 2.0},
+    ]
+    cues = build_cues(items, C)
+    assert cues[0][0] == 0.6 and abs(cues[0][1] - 3.6) < 1e-9  # 0.6 + 3.0，非 0.6+3.32
+    assert abs(cues[1][0] - 0.6 - round((3.0 + 0.32) * 30) / 30) < 1e-9
+
+
+def test_srt_golden():
+    items = [{"id": "p0-01", "scene": "P0", "text": "你好。", "durationSec": 3.0}]
+    srt = render_srt(build_cues(items, C))
+    assert srt == "1\n00:00:00,600 --> 00:00:03,600\n你好。\n"
+
+
+def test_vtt_header():
+    items = [{"id": "p0-01", "scene": "P0", "text": "你好。", "durationSec": 3.0}]
+    vtt = render_vtt(build_cues(items, C))
+    assert vtt.startswith("WEBVTT\n\n")
+    assert "00:00:00.600 --> 00:00:03.600" in vtt
diff --git a/media/pipeline/tests/test_check_script.py b/media/pipeline/tests/test_check_script.py
new file mode 100644
index 000000000..a3f3aa833
--- /dev/null
+++ b/media/pipeline/tests/test_check_script.py
@@ -0,0 +1,127 @@
+"""check_script 的覆盖性 / 预算 / 淡入不变式判定。"""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+SCRIPT = Path(__file__).resolve().parents[1] / "scripts" / "check_script.py"
+
+
+def run_check(root: Path, *extra: str) -> tuple[int, str]:
+    r = subprocess.run(
+        [sys.executable, str(SCRIPT), "--project", str(root), *extra],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    return r.returncode, r.stdout + r.stderr
+
+
+def write_board(root: Path, table: str) -> None:
+    (root / "script" / "storyboard.md").write_text(table, encoding="utf-8")
+
+
+def write_config(root: Path, toml: str) -> None:
+    (root / "pipeline.toml").write_text(toml, encoding="utf-8")
+
+
+BOARD_OK = """# 分镜
+## P0
+| 镜 | 句区间 | 画面 | 动效 |
+|---|---|---|---|
+| 0-A | p0-01..02 | x | y |
+## P1
+| 镜 | 句区间 | 画面 | 动效 |
+|---|---|---|---|
+| 1-A | p1-01..02 | x | y |
+"""
+
+CFG_OK = """[narration]
+target_minutes = [0.0, 99.0]
+chars_per_min = 280
+"""
+
+
+def test_all_green(project):
+    write_board(project, BOARD_OK)
+    write_config(project, CFG_OK)
+    rc, out = run_check(project)
+    assert rc == 0, out
+    assert not [line for line in out.splitlines() if line.strip().startswith("FAIL")]
+
+
+def test_missing_sentence_fails(project):
+    board = BOARD_OK.replace("| 1-A | p1-01..02 |", "| 1-A | p1-01..01 |")
+    write_board(project, board)
+    write_config(project, CFG_OK)
+    rc, out = run_check(project)
+    assert rc == 1
+    assert "p1-02" in out and "未覆盖" in out
+
+
+def test_unknown_id_fails(project):
+    board = BOARD_OK.replace("p1-01..02", "p1-01..p9-99")
+    write_board(project, board)
+    write_config(project, CFG_OK)
+    rc, out = run_check(project)
+    assert rc == 1
+    assert "p9-99" in out
+
+
+def test_overlap_warns_but_passes(project):
+    board = BOARD_OK.replace(
+        "| 0-A | p0-01..02 | x | y |",
+        "| 0-A | p0-01..02 | x | y |\n| 0-B | p0-02 | 标题卡 | 压尾 |",
+    )
+    write_board(project, board)
+    write_config(project, CFG_OK)
+    rc, out = run_check(project)
+    assert rc == 0  # WARN 不判死
+    assert "重叠" in out
+
+
+def test_annotated_overlap_silent(project):
+    board = BOARD_OK.replace(
+        "| 0-A | p0-01..02 | x | y |",
+        "| 0-A | p0-01..02 | x | y |\n| 0-B | p0-02 尾 | 标题卡 | 压尾 |",
+    )
+    write_board(project, board)
+    write_config(project, CFG_OK)
+    rc, out = run_check(project)
+    assert rc == 0
+    assert "重叠" not in out  # 「尾」标注 = 刻意惯例，静默
+
+
+def test_budget_window_fails(project):
+    write_board(project, BOARD_OK)
+    write_config(
+        project, "[narration]\ntarget_minutes = [0.0, 0.01]\nchars_per_min = 280\n"
+    )
+    rc, out = run_check(project)
+    assert rc == 1
+    assert "超预算" in out
+
+
+def test_measured_budget_uses_manifest(project):
+    write_board(project, BOARD_OK)
+    # fixture manifest 实测 ≈ (3.10+0.32)+(2.05+1.22)+(4.77+0.32)+(1.02)+tail 2.0 ≈ 14.8s
+    write_config(
+        project, "[narration]\ntarget_minutes = [0.0, 0.5]\nchars_per_min = 280\n"
+    )
+    rc, out = run_check(project)
+    assert rc == 0, out
+    assert "实测口径" in out
+
+
+def test_fade_invariant(project):
+    (project / "video/src/timing.json").write_text(
+        '{"fps":30,"sentenceGapSec":0.32,"sceneGapSec":0.9,"leadInSec":0.6,"tailSec":2.0,"sceneCrossFadeSec":0.9}',
+        encoding="utf-8",
+    )
+    write_board(project, BOARD_OK)
+    write_config(project, CFG_OK)
+    rc, out = run_check(project)
+    assert rc == 1
+    assert "淡入淡出" in out or "sceneCrossFadeSec" in out
diff --git a/media/pipeline/tests/test_check_series.py b/media/pipeline/tests/test_check_series.py
new file mode 100644
index 000000000..c084aa61c
--- /dev/null
+++ b/media/pipeline/tests/test_check_series.py
@@ -0,0 +1,128 @@
+"""check_series 五条规则的判定（用 tmp 仓库镜像，不依赖真实三集状态）。"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+SCRIPT = Path(__file__).resolve().parents[1] / "scripts" / "check_series.py"
+
+EP1 = {
+    "episode": 1,
+    "slug": "ep-a",
+    "path": "media/ep-a",
+    "title": "甲集标题",
+    "accents": ["#F5C542"],
+    "paper": {},
+}
+EP2 = {
+    "episode": 2,
+    "slug": "ep-b",
+    "path": "media/ep-b",
+    "title": "乙集标题",
+    "accents": ["#4A9EFF"],
+    "paper": {},
+}
+
+
+def build_repo(tmp_path: Path, episodes: list[dict], files: dict[str, str]) -> Path:
+    repo = tmp_path / "repo"
+    (repo / "media" / "pipeline" / "scripts").mkdir(parents=True)
+    for ep in episodes:
+        root = repo / ep["path"]
+        (root / "script").mkdir(parents=True)
+        (root / "script" / "narration.md").write_text(
+            "## P0\n\n- [p0-01] 独立成片。\n", encoding="utf-8"
+        )
+        (root / "README.md").write_text(f"# {ep['title']}\n", encoding="utf-8")
+        theme = root / "video/src/design/theme.ts"
+        theme.parent.mkdir(parents=True)
+        # 只落第一个 accent：让「清单多出的色」可被规则 4 抓到
+        theme.write_text(
+            f"export const theme = {{\n  x0: '{ep['accents'][0]}',\n}} as const;\n",
+            encoding="utf-8",
+        )
+    (repo / "media" / "series.json").write_text(
+        json.dumps(
+            {"series": {"id": "t", "title": "t", "rule": ""}, "episodes": episodes},
+            ensure_ascii=False,
+        ),
+        encoding="utf-8",
+    )
+    for rel, content in files.items():
+        dest = repo / rel
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        dest.write_text(content, encoding="utf-8")
+    return repo
+
+
+def run_check(repo: Path) -> tuple[int, str]:
+    # check_series 以脚本位置反推仓库根（parents[3]）；把脚本链路搬进 tmp 仓库镜像
+    mirror = repo / "media/pipeline/scripts/check_series.py"
+    mirror.write_bytes(Path(SCRIPT).read_bytes())
+    r = subprocess.run(
+        [sys.executable, str(mirror)],
+        capture_output=True,
+        text=True,
+        check=False,
+        cwd=repo,
+    )
+    return r.returncode, r.stdout + r.stderr
+
+
+def test_clean_repo_passes(tmp_path):
+    repo = build_repo(tmp_path, [EP1, EP2], {"docs/other.md": "无关内容\n"})
+    rc, out = run_check(repo)
+    assert rc == 0, out
+
+
+def test_spoken_other_title_fails(tmp_path):
+    repo = build_repo(tmp_path, [EP1, EP2], {})
+    (repo / EP1["path"] / "script/narration.md").write_text(
+        "## P0\n\n- [p0-02] 上期我们讲过《乙集标题》。\n", encoding="utf-8"
+    )
+    rc, out = run_check(repo)
+    assert rc == 1 and "规则1" in out and "乙集标题" in out
+
+
+def test_spoken_own_title_passes(tmp_path):
+    repo = build_repo(tmp_path, [EP1, EP2], {})
+    (repo / EP1["path"] / "script/narration.md").write_text(
+        f"## P0\n\n- [p0-02] 欢迎来到《{EP1['title']}》。\n- [p0-03] 我们下期再见。\n",
+        encoding="utf-8",
+    )
+    rc, out = run_check(repo)
+    assert rc == 0, out  # 自身标题 + 「下期」白名单
+
+
+def test_title_order_inverted_fails(tmp_path):
+    # 中性位置（非本集工程内）出现 ≥2 集标题时按首现位置判序——knowledge-map/CHANGELOG 场景
+    files = {"media/notes.md": "先提《乙集标题》再提《甲集标题》，顺序倒置。\n"}
+    repo = build_repo(tmp_path, [EP1, EP2], files)
+    rc, out = run_check(repo)
+    assert rc == 1 and "规则2" in out
+
+
+def test_ordinal_binding_fails(tmp_path):
+    files = {"media/notes.md": "第一集是《乙集标题》。\n"}
+    repo = build_repo(tmp_path, [EP1, EP2], files)
+    rc, out = run_check(repo)
+    assert rc == 1 and "规则3" in out
+
+
+def test_dead_link_fails(tmp_path):
+    files = {
+        "media/ep-a/README.md": "# 甲集标题\n[已删除](../../video-package/README.md)\n"
+    }
+    repo = build_repo(tmp_path, [EP1, EP2], files)
+    rc, out = run_check(repo)
+    assert rc == 1 and "规则5" in out and "video-package" in out
+
+
+def test_accent_not_in_theme_fails(tmp_path):
+    bad = {**EP1, "accents": ["#F5C542", "#123456"]}
+    repo = build_repo(tmp_path, [bad, EP2], {})
+    rc, out = run_check(repo)
+    assert rc == 1 and "#123456" in out
diff --git a/media/pipeline/tests/test_digest.py b/media/pipeline/tests/test_digest.py
new file mode 100644
index 000000000..b0fe0ea03
--- /dev/null
+++ b/media/pipeline/tests/test_digest.py
@@ -0,0 +1,122 @@
+"""digest 黄金值——「TTS 缓存零失效」的守门人。
+
+钉死 digest_indextts 的「未使用即省略」后缀规则：beams=1 不带 |beams=N、
+beams≥2 才带；emoref/emotext 同理。此前靠这条规则保住了已上线三集 596 句的
+缓存摘要 100% 不变；未来任何人改摘要公式，这里先红。
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "scripts"))
+from tts import digest_edge, digest_indextts  # noqa: E402
+
+
+def test_digest_indextts_golden():
+    vec = (0.95, 0, 0, 0, 0, 0, 0.02, 0.03)
+    # beams=1（省略后缀）——与已上线 passionate 句同构
+    d1 = digest_indextts(
+        "3ed0d9d60d4b",
+        "passionate",
+        vec,
+        0.7,
+        0.97,
+        "ZH",
+        "indextts",
+        "测试句。",
+        1,
+        None,
+        None,
+    )
+    # beams=3（带 |beams=3）
+    d3 = digest_indextts(
+        "3ed0d9d60d4b",
+        "passionate",
+        vec,
+        0.7,
+        0.97,
+        "ZH",
+        "indextts",
+        "测试句。",
+        3,
+        None,
+        None,
+    )
+    # emoref / emotext 后缀
+    dr = digest_indextts(
+        "3ed0d9d60d4b",
+        "emoref",
+        None,
+        1.0,
+        1.0,
+        "ZH",
+        "indextts",
+        "测试句。",
+        1,
+        "aabbccddeeff",
+        None,
+    )
+    dt = digest_indextts(
+        "3ed0d9d60d4b",
+        "emotext",
+        None,
+        1.0,
+        1.0,
+        "ZH",
+        "indextts",
+        "测试句。",
+        1,
+        None,
+        "轻快爽朗",
+    )
+
+    # 黄金值按实现真实序列化拍死：vec 用 repr(x) 逐项、None→"none"、alpha/df 用 !r。
+    # 若此处失败且你有意修改摘要公式：须全量评估三集已上线缓存失效，并同步更新 VOICE-CLONING.md §六。
+    import hashlib
+
+    def manual(suffix: str) -> str:
+        vec_str = ",".join(repr(x) for x in vec)
+        raw = f"indextts|indextts|3ed0d9d60d4b|ZH|passionate|{vec_str}|{0.7!r}|{0.97!r}|测试句。{suffix}"
+        return hashlib.sha1(raw.encode()).hexdigest()
+
+    assert d1 == manual(""), "beams=1 不得带后缀"
+    assert d3 == manual("|beams=3"), "beams=3 须带 |beams=3"
+    assert d1 != d3, "束宽必须参与摘要（换束宽=换缓存）"
+    assert dr and dr != d1
+    assert dt and dt not in (d1, dr)
+    # 确定性
+    assert d1 == digest_indextts(
+        "3ed0d9d60d4b",
+        "passionate",
+        vec,
+        0.7,
+        0.97,
+        "ZH",
+        "indextts",
+        "测试句。",
+        1,
+        None,
+        None,
+    )
+
+    # 逐字黄金（防 repr 语义漂移，如 0.7 → 0.70）
+    assert d1 == "b6ccdeea2d913069c87bb679d67043a602bddfcb", d1
+    assert d3 == "e0750477d554fb14bf9753c4363ab27869df6cac", d3
+
+
+def test_digest_indextts_vec_none_serialization():
+    import hashlib
+
+    d = digest_indextts(
+        "abc", "emoref", None, 1.0, 1.0, "ZH", "indextts", "x", 2, "ff", None
+    )
+    raw = "indextts|indextts|abc|ZH|emoref|none|1.0|1.0|x|beams=2|emoref=ff"
+    assert d == hashlib.sha1(raw.encode()).hexdigest()
+
+
+def test_digest_edge_golden():
+    import hashlib
+
+    assert digest_edge("v", "r", "t") == hashlib.sha1(b"v|r|t").hexdigest()
diff --git a/media/pipeline/tests/test_engine_guard.py b/media/pipeline/tests/test_engine_guard.py
new file mode 100644
index 000000000..399f219cb
--- /dev/null
+++ b/media/pipeline/tests/test_engine_guard.py
@@ -0,0 +1,62 @@
+"""tts.py 引擎护栏：漏写 --engine 的克隆参数硬失败 + 音色签名标记。"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "scripts"))
+from tts import check_voice_marker, server_launch_hint, write_voice_marker  # noqa: E402
+
+
+def test_engine_guard_blocks_clone_flags_without_engine(tmp_path):
+    """照抄文档打了 --ref/--style 却丢了 --engine → 必须退出非零（合成路径不再静默降级）。"""
+    import subprocess
+
+    script = Path(__file__).resolve().parents[1] / "scripts" / "tts.py"
+    r = subprocess.run(
+        [sys.executable, str(script), "--style", "sunny"],
+        capture_output=True,
+        text=True,
+        check=False,
+        cwd=tmp_path,
+    )
+    assert r.returncode != 0
+    assert "--engine indextts" in (r.stderr + r.stdout)
+
+
+def test_voice_marker_mismatch_blocks(tmp_path, capsys):
+    write_voice_marker(tmp_path, "indextts|indextts|passionate|3ed0d9d60d4b")
+    try:
+        check_voice_marker(
+            tmp_path, "indextts|indextts|sunny|54b699cce97f", allow_switch=False
+        )
+        raise AssertionError("应硬失败")
+    except SystemExit as e:
+        assert "音色签名与上次合成不一致" in str(e.code)
+        assert "--allow-voice-switch" in str(e.code)
+
+
+def test_voice_marker_same_signature_passes(tmp_path):
+    write_voice_marker(tmp_path, "edge|zh-CN-YunxiNeural|+4%")
+    check_voice_marker(
+        tmp_path, "edge|zh-CN-YunxiNeural|+4%", allow_switch=False
+    )  # 不抛即过
+
+
+def test_voice_marker_explicit_switch_allowed(tmp_path):
+    write_voice_marker(tmp_path, "edge|zh-CN-YunxiNeural|+4%")
+    check_voice_marker(
+        tmp_path, "indextts|indextts|sunny|54b699cce97f", allow_switch=True
+    )
+
+
+def test_voice_marker_absent_passes(tmp_path):
+    check_voice_marker(tmp_path, "whatever", allow_switch=False)  # 无标记（首次合成）
+
+
+def test_server_launch_hint_has_no_placeholder():
+    hint = server_launch_hint()
+    assert "<仓库路径>" not in hint
+    assert "tts_server.py" in hint and "index-tts" in hint
+    assert "checkpoints" in hint
diff --git a/media/pipeline/tests/test_qa_checks.py b/media/pipeline/tests/test_qa_checks.py
new file mode 100644
index 000000000..84bc6e149
--- /dev/null
+++ b/media/pipeline/tests/test_qa_checks.py
@@ -0,0 +1,126 @@
+"""qa_check 判据（PIL 合成图）与 WCAG 对比度计算。"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import numpy as np
+from PIL import Image
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "scripts"))
+from qa_frames import check_frames, check_theme, tail_row_has_fade, wcag_ratio  # noqa: E402
+
+
+def make_png(path: Path, mode: str, scale: float = 1.0) -> None:
+    w, h = round(1920 * scale), round(1080 * scale)
+    arr = np.zeros((h, w), dtype=np.uint8)  # 深色底 #0E1116 ≈ 17
+    arr[:] = 17
+    if mode == "subtitle":  # 底部中央字幕条（亮块）
+        bw = round(600 * scale)
+        x0 = (w - bw) // 2
+        arr[h - round(80 * scale) : h - round(20 * scale), x0 : x0 + bw] = 235
+    elif mode == "intrude":  # 字幕带左侧侵入的亮角标
+        arr[
+            h - round(120 * scale) : h - round(40 * scale),
+            round(60 * scale) : round(220 * scale),
+        ] = 210
+    elif mode == "bright":
+        arr[:] = 120
+    path.write_bytes(b"")
+    Image.fromarray(arr).save(path)
+
+
+def run_check(tmp_path: Path, names: list[str], scale: float = 1.0) -> list[str]:
+    out = tmp_path / "frames"
+    out.mkdir(exist_ok=True)
+    for n in names:
+        make_png(
+            out / f"{n}.png",
+            n if n.startswith(("subtitle", "intrude", "bright")) else "subtitle",
+            scale,
+        )
+    msgs: list[str] = []
+    check_frames(out, names, scale, fade_exempt_last=False, msgs=msgs)
+    return msgs
+
+
+def test_black_frame_fails(tmp_path):
+    msgs = run_check(tmp_path, ["bright", "subtitle"], scale=1.0)
+    # 直接构造全黑帧再测
+    out = tmp_path / "frames"
+    Image.fromarray(np.zeros((1080, 1920), dtype=np.uint8)).save(out / "p9-99.png")
+    msgs = []
+    check_frames(out, ["p9-99"], 1.0, False, msgs)
+    assert any("黑帧" in m and m.startswith("FAIL") for m in msgs)
+
+
+def test_normal_subtitle_frame_clean(tmp_path):
+    msgs = run_check(tmp_path, ["subtitle"])
+    assert not any(m.startswith("FAIL") for m in msgs)
+    assert not any("侵入" in m for m in msgs)
+
+
+def test_intrusion_warns(tmp_path):
+    # 需要同时有字幕块与左侧侵入块——intrude 模式画在字幕带左外侧
+    out = tmp_path / "frames"
+    out.mkdir(exist_ok=True)
+    w, h = 1920, 1080
+    arr = np.full((h, w), 17, dtype=np.uint8)
+    arr[h - 80 : h - 20, (w - 600) // 2 : (w + 600) // 2] = 235  # 字幕
+    arr[h - 120 : h - 40, 60:220] = 210  # 左侧角标侵入
+    Image.fromarray(arr).save(out / "p5-99.png")
+    msgs: list[str] = []
+    check_frames(out, ["p5-99"], 1.0, False, msgs)
+    assert any("侵入" in m for m in msgs)
+
+
+def test_frozen_frame_warns(tmp_path):
+    out = tmp_path / "frames"
+    out.mkdir(exist_ok=True)
+    img = np.full((1080, 1920), 17, dtype=np.uint8)
+    img[100:200, 100:400] = 200
+    for n in ("p2-01", "p2-02"):
+        Image.fromarray(img).save(out / f"{n}.png")
+    msgs: list[str] = []
+    check_frames(out, ["p2-01", "p2-02"], 1.0, False, msgs)
+    assert any("冻帧" in m for m in msgs)
+
+
+def test_wcag_known_ratios():
+    # WCAG 2.x 已知值：黑 vs 白 = 21:1；#F5C542 vs #0E1116 ≈ 11.66:1（与三集实测一致）
+    assert abs(wcag_ratio((0, 0, 0), (255, 255, 255)) - 21.0) < 0.01
+    assert abs(wcag_ratio((245, 197, 66), (14, 17, 22)) - 11.66) < 0.05
+
+
+def test_theme_check_passes_and_fails(tmp_path):
+    theme = tmp_path / "video/src/design/theme.ts"
+    theme.parent.mkdir(parents=True)
+    theme.write_text(
+        "export const theme = {\n  bg: '#0E1116',\n  good: '#F5C542',\n  bad: '#5A6274',\n} as const;\n",
+        encoding="utf-8",
+    )
+    msgs: list[str] = []
+    check_theme(tmp_path, msgs)
+    joined = "\n".join(msgs)
+    assert "good" not in joined  # 4.5:1 以上不进 msgs
+    assert any("bad" in m and m.startswith("FAIL") for m in msgs)
+
+
+def test_tail_row_has_fade_ignores_trailing_prose(tmp_path):
+    """渐黑行距文件末尾有散文节时（EP1/EP2 真实形态），豁免仍须命中。"""
+    board = tmp_path / "storyboard.md"
+    board.write_text(
+        "| 6-F2 三条曲线 | p6-13c..13d | … | 三线描画 |\n"
+        "| 6-G 原文卡 | p6-14..15 | …；渐黑 | 卡片停留 + 渐黑 |\n"
+        "\n## 字幕规范\n\n- 单行字幕。\n\n## 实现映射\n\n每幕一个组件。\n",
+        encoding="utf-8",
+    )
+    assert tail_row_has_fade(board)
+
+
+def test_tail_row_has_fade_false_without_marker(tmp_path):
+    board = tmp_path / "storyboard.md"
+    board.write_text("| 6-G 原文卡 | p6-14..15 | … | 卡片停留 |\n", encoding="utf-8")
+    assert not tail_row_has_fade(board)
+    assert not tail_row_has_fade(tmp_path / "absent.md")  # 缺文件不炸、不豁免
diff --git a/media/pipeline/tests/test_timeline.py b/media/pipeline/tests/test_timeline.py
new file mode 100644
index 000000000..79f57247f
--- /dev/null
+++ b/media/pipeline/tests/test_timeline.py
@@ -0,0 +1,84 @@
+"""timeline.compute 与 timing.ts:computeTimeline 的同构性（黄金帧号）。"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "scripts"))
+from timeline import (  # noqa: E402
+    compute,
+    js_round,
+    load_constants,
+    total_duration_in_frames,
+)
+
+C = {
+    "fps": 30,
+    "sentenceGapSec": 0.32,
+    "sceneGapSec": 0.9,
+    "leadInSec": 0.6,
+    "tailSec": 2.0,
+}
+
+
+def test_golden_frames():
+    items = [
+        {"id": "p0-01", "scene": "P0", "text": "a", "durationSec": 4.10},
+        {"id": "p0-02", "scene": "P0", "text": "b", "durationSec": 1.05},
+        {
+            "id": "p1-01",
+            "scene": "P1",
+            "text": "c",
+            "durationSec": 0.02,
+        },  # 极短句触发 max(1,..)
+        {"id": "p1-02", "scene": "P1", "text": "d", "durationSec": 3.77},
+    ]
+    rows = compute(items, C)
+    # 黄金值 = 手推 timing.ts 公式：leadIn 0.6*30=18 起；
+    # p0-01 dur = round((4.10+0.32)*30)=133；p0-02 = round((1.05+0.32+0.9)*30)=68（幕界 gap 只加一次）
+    # p1-01 = max(1, round((0.02+0.32)*30))=11（截断为 10.2 → 10）；p1-02 = round((3.77+0.32)*30)=123
+    assert [r["fromFrame"] for r in rows] == [18, 151, 219, 229]
+    assert [r["durationInFrames"] for r in rows] == [133, 68, 10, 123]
+
+
+def test_total_includes_tail():
+    items = [{"id": "p0-01", "scene": "P0", "text": "a", "durationSec": 4.10}]
+    assert total_duration_in_frames(items, C) == 18 + 133 + round(2.0 * 30)
+
+
+def test_js_round_matches_math_round_semantics():
+    """js_round = JS Math.round（.5 恒向上），非 banker's rounding——
+    (0.03+0.32)*30 = 10.5 类精确 .5 落点上，内置 round() 会给 10 而 JS 给 11，
+    从该句起抽帧帧号整体漂移。"""
+    assert js_round(10.5) == 11  # 内置 round(10.5) == 10
+    assert js_round(0.5) == 1  # 内置 round(0.5) == 0
+    assert js_round(2.5) == 3  # 内置 round(2.5) == 2
+    assert js_round(100.49999999999999) == 100  # 非精确 .5 时与内置一致
+    # 真实形态：(0.03+0.32)*30 恰为 10.5 —— durationSec 三位小数可命中的边界类
+    assert js_round((0.03 + 0.32) * 30) == 11
+    assert (
+        compute([{"id": "p0-01", "scene": "P0", "text": "x", "durationSec": 0.03}], C)[
+            0
+        ]["durationInFrames"]
+        == 11
+    )
+
+
+def test_load_constants_missing_exits(tmp_path):
+    import pytest
+
+    with pytest.raises(SystemExit, match="timing.json 不存在"):
+        load_constants(tmp_path)
+
+
+def test_load_constants_missing_fields(tmp_path):
+    import json
+
+    import pytest
+
+    p = tmp_path / "video/src/timing.json"
+    p.parent.mkdir(parents=True)
+    p.write_text(json.dumps({"fps": 30}), encoding="utf-8")
+    with pytest.raises(SystemExit, match="缺少字段"):
+        load_constants(tmp_path)
diff --git a/media/pipeline/voices/refs.toml b/media/pipeline/voices/refs.toml
new file mode 100644
index 000000000..c994b6038
--- /dev/null
+++ b/media/pipeline/voices/refs.toml
@@ -0,0 +1,23 @@
+# 参考音色样本清单（唯一入库文件——voices/ 其余内容因生物特征隐私被 gitignore，
+# 本文件经 .gitignore 白名单例外放行）。指纹口径：sha1 取前 12 位（同 tts.py 摘要），
+# sha256 为完整指纹（人工核对用）。verify/rebuild 见 scripts/refs.py。
+#
+# 关键背景：sunny / sunny-steady 预设的 alpha=0.35 是在 me-bright 选段上标定的
+#（Qwen 原始 Σ=0.8 会把克隆音高推到 199–223 Hz，本人自然区间 142–163 Hz），
+# 复现的不是这个选段，标定即失效——重建后必须 verify。
+
+[me-bright]
+source = "~/Documents/dify/me-1.mp3"
+start = 0.36
+duration = 12
+sha1 = "54b699cce97f"
+sha256 = ""   # 首次 verify 通过后回填（样本不在库，无法预置）
+locked_styles = ["sunny", "sunny-steady"]
+
+[me-1]
+source = "~/Documents/dify/me-1.mp3"
+start = 180
+duration = 12
+sha1 = "3ed0d9d60d4b"
+sha256 = ""
+locked_styles = ["passionate", "neutral"]   # 已上线三集成片所用样本
diff --git a/media/self-evolving-coding-agents-video/README.md b/media/self-evolving-coding-agents-video/README.md
index 0e723c9cb..ef5a8b3e5 100644
--- a/media/self-evolving-coding-agents-video/README.md
+++ b/media/self-evolving-coding-agents-video/README.md
@@ -3,7 +3,7 @@
 > 基于 H. Zhou, H. Hu, Y. Shang, Q. Zhang, "Self-Evolving Coding Agents: A Survey," arXiv:2608.03392, Aug. 2026（南京理工大学 × 南京大学综述）的动效图解式科普视频（B 站/YouTube，目标 14.5–15.5 分钟）。
 > 形态：**本人音色克隆配音**（IndexTTS-2.5，passionate 激情风格）+ Remotion 代码动画，无真人出镜。
 > （v3 前为 edge-tts 预置音色，两种引擎 manifest 契约一致，可随时切回。）
-> 系列第三集（各自独立成片）：第一集《AI 如何自己变强？》（[../self-improving-agents-video/](../self-improving-agents-video/README.md)，通用·自我进化改什么）→ 第二集《上线之后，AI 才开始上学》（[../experience-era-agents-video/](../experience-era-agents-video/README.md)，通用·部署后经验怎么攒）→ 本集**领域深潜**：自进化最先真实落地的田野——代码（可执行反馈让进化可测量）。片尾三卡回顾。
+> 系列第三集（各集独立成片，口播不出现他集标题与集数序号）：前两集讲通用道理——[《上线之后，AI 才开始上学》](../experience-era-agents-video/README.md)（部署后经验怎么攒）、[《AI 如何自己变强？》](../self-improving-agents-video/README.md)（自我进化改什么）；本集**领域深潜**：自进化最先真实落地的田野——代码（可执行反馈让进化可测量）。片尾三卡回顾，顺序以 [../series.json](../series.json) 为准。
 
 ## 目录结构
 
@@ -14,6 +14,7 @@
 | `script/narration.md` | 逐字稿（唯一维护处），`- [句id] 文本` 一句一行 |
 | `script/narration.json` | 派生物：拆句结果，供 TTS 与字幕消费（勿手改） |
 | `script/storyboard.md` | 分镜表：镜号 ↔ 句 id 区间 ↔ 画面动效（场景组件实现规格） |
+| `pipeline.toml` | 本集管线配置（配音/渲染/时长预算）——`pipeline.py` 的参数源 |
 | `scripts/*.py` | 薄包装 → 公共管线 [media/pipeline/scripts/](../pipeline/scripts/)（`--project` 透传） |
 | `video/` | Remotion 工程（独立 pnpm 项目，`ignore-workspace` 与主仓隔离） |
 | `out/` | 渲染产物（gitignored） |
@@ -24,10 +25,9 @@
 # 1. 改稿后重建逐句 JSON
 uv run --no-project scripts/build_narration.py
 
-# 2. 合成配音（本人音色克隆，增量幂等；需先启动 IndexTTS 服务，见 ../../pipeline/VOICE-CLONING.md）
-uv run --no-project --with mutagen scripts/tts.py --engine indextts \
-    --ref <仓库绝对路径>/media/pipeline/voices/me-1.wav --style passionate
-#    （声音样本不入库：me-1.wav 需从本人录音经 prepare_ref.py 裁剪生成；整集约数小时，断点续跑）
+# 2. 合成配音（本人音色克隆，增量幂等；参数读自本集 pipeline.toml（复现已上线音频的档：passionate + me-1.wav）；
+#    需先启动 IndexTTS 服务，见 ../pipeline/VOICE-CLONING.md）
+uv run --no-project ../pipeline/scripts/pipeline.py --project . tts
 
 # 3. 预览（工具一律 ./node_modules/.bin/ 直调，防 pnpm run 污染根 workspace node_modules）
 cd video && pnpm install --ignore-workspace && ./node_modules/.bin/remotion studio
@@ -58,4 +58,4 @@ cd video && ./node_modules/.bin/remotion render Main ../out/final.mp4
 
 ## 许可注意
 
-Remotion 对超过 3 人的公司需商业授权（个人/小团队免费）；若本视频转为公司用途，请评估许可或迁移 MIT 协议的 Motion Canvas。配音为**本人声音的自愿克隆**（IndexTTS-2.5，按 bilibili 模型使用许可：个人/研究用途可用，商用需联系 indexspeech@bilibili.com；克隆他人声音须获本人书面同意，详见 [../../pipeline/VOICE-CLONING.md](../../pipeline/VOICE-CLONING.md) §八）。发布前请自行确认平台对合成语音的标注要求。
+Remotion 对超过 3 人的公司需商业授权（个人/小团队免费）；若本视频转为公司用途，请评估许可或迁移 MIT 协议的 Motion Canvas。配音为**本人声音的自愿克隆**（IndexTTS-2.5，按 bilibili 模型使用许可：个人/研究用途可用，商用需联系 indexspeech@bilibili.com；克隆他人声音须获本人书面同意，详见 [../pipeline/VOICE-CLONING.md](../pipeline/VOICE-CLONING.md) §八）。发布前请自行确认平台对合成语音的标注要求。
diff --git a/media/self-evolving-coding-agents-video/pipeline.toml b/media/self-evolving-coding-agents-video/pipeline.toml
new file mode 100644
index 000000000..3892ff9b3
--- /dev/null
+++ b/media/self-evolving-coding-agents-video/pipeline.toml
@@ -0,0 +1,25 @@
+# 《会写代码的 AI，开始给自己写代码》管线配置——pipeline.py 的默认参数源。
+# 可执行参数只落此处，README 不再复制粘贴命令行（防 ISSUE-161 类漂移）；
+# CLI 显式参数仍可覆盖本文件。
+
+[episode]
+slug  = "self-evolving-coding-agents-video"
+title = "会写代码的 AI，开始给自己写代码"
+
+[narration]
+target_minutes = [12.0, 15.0]
+chars_per_min  = 280
+
+[tts]
+# ⚠️ 本配置记录的是「复现已上线音频」的档：三集成片统一 passionate + me-1.wav。
+# 摘要含 style 与 ref_sha1，改档 = 整集重合成（须 --allow-voice-switch 显式放行）。
+# 升级 sunny-steady 属独立重录决策，登记于 media/series.json 的待升级项。
+engine   = "indextts"
+ref      = "media/pipeline/voices/me-1.wav"
+ref_sha1 = "3ed0d9d60d4b"
+style    = "passionate"
+lang     = "ZH"
+
+[render]
+draft_scale        = 0.5
+draft_jpeg_quality = 60
diff --git a/media/self-evolving-coding-agents-video/research/paper-notes.md b/media/self-evolving-coding-agents-video/research/paper-notes.md
index 3e9fb2f29..8121e0851 100644
--- a/media/self-evolving-coding-agents-video/research/paper-notes.md
+++ b/media/self-evolving-coding-agents-video/research/paper-notes.md
@@ -5,7 +5,7 @@
 > **用途**：本笔记是科普视频《会写代码的 AI，开始给自己写代码》的**单一事实源**——逐字稿中的每个论文断言必须能回溯到本文件的对应条目。
 > **提取方式**：2026-08-17 由 8 个并行提取代理对论文 HTML 全文逐节精读产出（A: 摘要+§1；B: §2+Table 1；C–F: §3.1–3.4 各一；G: §3.5+§4；H: §5–7+Table 2 结构）。
 > **配套资源**：论文附论文列表仓库 Awesome-Self-Evolving-Coding-Agents（https://github.com/zhouhao1024/Awesome-Self-Evolving-Coding-Agents）。
-> **与本系列前两集的关系**：第一集《AI 如何自己变强？》（arXiv:2607.13104，通用·自我进化改什么：大脑 θ/装备 Σ）；第二集《上线之后，AI 才开始上学》（清华×Frontis 综述，通用·部署后经验怎么攒：Harness/trace→z/四去处/元进化）。本集论文**领域深潜**：自进化编码智能体——自进化最先真实落地的田野（可执行反馈让进化可测量）。三集互补且各自独立成片。
+> **与同系列另两集的关系**：《上线之后，AI 才开始上学》（清华×Frontis 综述，通用·部署后经验怎么攒：Harness/trace→z/四去处/元进化）、《AI 如何自己变强？》（arXiv:2607.13104，通用·自我进化改什么：大脑 θ/装备 Σ）。本集论文**领域深潜**：自进化编码智能体——自进化最先真实落地的田野（可执行反馈让进化可测量）。三集互补且各自独立成片（发布顺序见 [../../series.json](../../series.json)）。
 
 
 ---
diff --git a/media/self-evolving-coding-agents-video/script/narration.json b/media/self-evolving-coding-agents-video/script/narration.json
index 8c453fe91..2494bed1b 100644
--- a/media/self-evolving-coding-agents-video/script/narration.json
+++ b/media/self-evolving-coding-agents-video/script/narration.json
@@ -902,12 +902,12 @@
   {
     "id": "p6-09",
     "scene": "P6",
-    "text": "第一集讲自我进化在改什么，"
+    "text": "前两集讲的是通用的道理："
   },
   {
     "id": "p6-10",
     "scene": "P6",
-    "text": "第二集讲部署之后经验怎么攒，"
+    "text": "经验怎么攒，自己该改哪儿；"
   },
   {
     "id": "p6-11",
diff --git a/media/self-evolving-coding-agents-video/script/narration.md b/media/self-evolving-coding-agents-video/script/narration.md
index ce2fef199..edc247710 100644
--- a/media/self-evolving-coding-agents-video/script/narration.md
+++ b/media/self-evolving-coding-agents-video/script/narration.md
@@ -335,11 +335,11 @@
 - [p6-06] 论文的原话是：几乎还没人探索过。
 - [p6-07] 答案，可能就在看视频的你们中间。
 
-> 画面：系列三卡并排：《AI 如何自己变强？》（蓝橙）/《上线之后，AI 才开始上学》（金青紫）/ 本集（绿洋红）。
+> 画面：系列三卡并排：《上线之后，AI 才开始上学》（金青紫）/《AI 如何自己变强？》（蓝橙）/ 本集（绿洋红）。
 
 - [p6-08] 这个系列已经三集了。
-- [p6-09] 第一集讲自我进化在改什么，
-- [p6-10] 第二集讲部署之后经验怎么攒，
+- [p6-09] 前两集讲的是通用的道理：
+- [p6-10] 经验怎么攒，自己该改哪儿；
 - [p6-11] 这一集，我们走进了进化最先落地的田野：代码。
 - [p6-12] 论文作者还维护着一个配套的论文清单，
 - [p6-13] 感兴趣的同学可以去翻。
diff --git a/media/self-evolving-coding-agents-video/script/planning.md b/media/self-evolving-coding-agents-video/script/planning.md
index e90dd2684..e4ff59bec 100644
--- a/media/self-evolving-coding-agents-video/script/planning.md
+++ b/media/self-evolving-coding-agents-video/script/planning.md
@@ -12,7 +12,7 @@
 | 形态 | 动效图解式：AI 配音（edge-tts）+ Remotion 代码动画，无真人出镜 |
 | 受众 | 对 AI 好奇的普通观众；不预设机器学习或软件工程背景 |
 | 核心内容 | 全文主线：概念边界（三圈）→ 五个进化的对象 → 时机×证据 → 评测 → 可信进化 |
-| 系列关系 | 第三集=**领域深潜**：前两集讲通用道理（ep1 自我进化改什么 / ep2 部署后经验怎么攒），本集看自进化最先真实落地的田野——代码（可执行反馈让进化可测量）；片尾三卡回顾，各集独立成片 |
+| 系列关系 | 第三集=**领域深潜**：前两集讲通用道理（部署后经验怎么攒 / 自我进化改什么），本集看自进化最先真实落地的田野——代码（可执行反馈让进化可测量）；片尾三卡回顾，顺序以 [../../series.json](../../series.json) 为准，各集独立成片 |
 
 ## 二、叙事策略
 
@@ -25,7 +25,7 @@
    - P3「一次报错当场改补丁，反复报错升级成记忆」「成绩单只有名次没有评语」「测试跑一遍，骗不了人」
    - P4「SWE-bench：真修好一个真实 issue，不是做选择题」「刷分≠进化」
    - P5「一滴墨掉进水库」（坏信号跨代遗传）、「错误的测试会教坏 agent」、KEY QUOTE 金句卡
-   - P6 三集拼图卡（ep1 改什么 / ep2 怎么攒 / ep3 代码领域全图）
+   - P6 三集拼图卡（怎么攒 / 改什么 / 代码领域全图，顺序以 series.json 为准）
 4. **理性收尾**：论文落点不是「AI 终将取代程序员」，而是工程命题——进化要过验证之门（验反馈/修记忆/审技能/限自改/评长期五机制）；开放问题留给观众（学到的进化能否迁移出代码世界，论文说 largely unexplored）。
 
 ## 三、视觉语言（本集独立契约）
@@ -50,7 +50,7 @@
 | P3 | 8:00–10:00 | 何时进化×凭什么进化 | WHEN 三态：**干活时**（task-time：测试一挂当场改，Live-SWE-Agent 现场造工具）/ **下班后**（post-task：复盘成记忆技能，「工单进教科书而非废纸篓」）/ **攒批换代**（stage-wise：一批轨迹攒成训练信号，影响未来版本）× EVIDENCE 三源：**结果证据**（跑分=选择压，但「成绩单只有名次没有评语」）/ **环境反馈**（编译器/测试日志=仪表盘直播，最即时）/ **轨迹证据**（完整过程录像，价值最高但要剪辑抽象）→ 3×3 矩阵合成 → Table 2 规律：改组织当场改、改模型必须攒批、攒记忆靠复盘 → 软件王牌：**可执行证据，测试跑一遍骗不了人** | 秒表/日记本/进化树三格漫画；成绩单（名次有/评语空）；仪表盘；录像带→招式卡片；3×3 矩阵网格逐格点亮（位置编码不用色） |
 | P4 | 10:00–12:00 | 怎么知道真的变强了 | **SWE-bench 家族=真实 GitHub issue+执行验证**（真修好才算过，不是做选择题；Lite/Verified/Pro 变体）→ 函数级基准（HumanEval 等）只是体检指标，仓库级才是临床手术 → 分数涨了但分数不招供（功劳属于记忆？技能？工作流？模型？五个嫌疑人）→ 更完整的评测：成本/token/步数/跨仓库迁移 → **缺口：可维护性/安全/长期可靠性几乎没人测**；「在哪儿进化的，出了那间教室还算数吗」 | 真实 issue 卡+测试跑绿勾；选择题 vs 修 bug 对比；五个嫌疑人剪影+孤零零分数；六维雷达图；教室门意象 |
 | P5 | 12:00–14:00 | 进化要可信 | 挑战升维：**一滴墨掉进水库**（不可靠的测试不只毁一个补丁，会被存成记忆/蒸馏成技能/选成工作流/写进模型——跨代遗传）→ 复现难（每次运行代理都在变；背题/刷榜/对公开信号过拟合三种假动作）→ **反馈可靠性：错误的测试会教坏 agent**（被污染的裁判改写球员今后全部打法）→ 记忆库四宗罪（过期/冗余/认死一个仓库/被失败轨迹污染）→ 工具可靠性不是实现细节而是正题 → **KEY QUOTE 金句卡**：「不只是让编码智能体进化，而是让它们的进化 trustworthy」+ 五机制清单（验反馈/修记忆/审技能/限自改/评长期） | 墨滴入水库全链变黑；三假动作小剧场；裁判被污染；图书馆发霉/复印/伪证；绿色大门+五格清单；衬线绿字金句卡 |
-| P6 | 14:00–15:20 | 收尾 | 五对象一帧回顾+可信进化绿门收束 → **系列三卡**：ep1《AI 如何自己变强？》（蓝橙·自我进化改什么）/ ep2《上线之后，AI 才开始上学》（金青紫·经验怎么攒）/ ep3 本集（绿洋红·代码领域全图）→ 开放问题：学到的进化能否迁移出代码世界（largely unexplored）→ 配套仓库 Awesome-Self-Evolving-Coding-Agents → 引用卡 arXiv:2608.03392 渐黑 | 五器官地图缩略回顾；三集拼图卡并排；星空单问号；引用卡 |
+| P6 | 14:00–15:20 | 收尾 | 五对象一帧回顾+可信进化绿门收束 → **系列三卡**：《上线之后，AI 才开始上学》（金青紫·经验怎么攒）/《AI 如何自己变强？》（蓝橙·自我进化改什么）/ 本集（绿洋红·代码领域全图）→ 开放问题：学到的进化能否迁移出代码世界（largely unexplored）→ 配套仓库 Awesome-Self-Evolving-Coding-Agents → 引用卡 arXiv:2608.03392 渐黑 | 五器官地图缩略回顾；三集拼图卡并排；星空单问号；引用卡 |
 
 ## 五、生产管线
 
diff --git a/media/self-evolving-coding-agents-video/script/storyboard.md b/media/self-evolving-coding-agents-video/script/storyboard.md
index 367405d65..e19c7799f 100644
--- a/media/self-evolving-coding-agents-video/script/storyboard.md
+++ b/media/self-evolving-coding-agents-video/script/storyboard.md
@@ -89,7 +89,7 @@
 |---|---|---|---|
 | 6-A 地图回顾 | p6-01..03 | 缩略全景：五器官地图 + 3×3 矩阵 + 考场 + 绿门四元素拼成一屏 | 四元素拼图合拢 |
 | 6-B 开放问题 | p6-04..07 | 星空；一个大问号星座：「代码学到的进化，能带出代码世界吗？」；角标 largely unexplored | 星座连线点亮 |
-| 6-C 系列三卡 | p6-08..11 | 三张卡并排：《AI 如何自己变强？》（蓝橙光带）《上线之后，AI 才开始上学》（金青紫光带）本集（绿洋红光带）；各自一行副标题 | 三卡依次翻入 + 光带流动 |
+| 6-C 系列三卡 | p6-08..11 | 三张卡并排：《上线之后，AI 才开始上学》（金青紫光带）《AI 如何自己变强？》（蓝橙光带）本集（绿洋红光带）；各自一行副标题 | 三卡依次翻入 + 光带流动 |
 | 6-D 配套仓库 | p6-12..13 | GitHub 仓库卡：Awesome-Self-Evolving-Coding-Agents（mono 字体 URL） | 卡片滑入 |
 | 6-E 引用卡收束 | p6-14..17 | 论文引用卡：arXiv:2608.03392 + 南京理工大学 × 南京大学；末句时「门后站着验证」小图（绿门+人影）；渐黑 | 卡片停留 + 缓慢渐黑（时长从末 beat 总时长实时推导） |
 
diff --git a/media/self-evolving-coding-agents-video/video/package.json b/media/self-evolving-coding-agents-video/video/package.json
index 1f430dd92..d27caa31f 100644
--- a/media/self-evolving-coding-agents-video/video/package.json
+++ b/media/self-evolving-coding-agents-video/video/package.json
@@ -10,6 +10,8 @@
   },
   "dependencies": {
     "@remotion/cli": "^4.0.0",
+    "@remotion/layout-utils": "4.0.512",
+    "@remotion/media": "4.0.512",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
     "remotion": "^4.0.0"
diff --git a/media/self-evolving-coding-agents-video/video/pnpm-lock.yaml b/media/self-evolving-coding-agents-video/video/pnpm-lock.yaml
index a9815bab6..d37f0e832 100644
--- a/media/self-evolving-coding-agents-video/video/pnpm-lock.yaml
+++ b/media/self-evolving-coding-agents-video/video/pnpm-lock.yaml
@@ -11,6 +11,12 @@ importers:
       '@remotion/cli':
         specifier: ^4.0.0
         version: 4.0.512(postcss@8.5.26)(react-dom@19.2.8(react@19.2.8))(react@19.2.8)(supports-color@8.1.1)(typescript@5.9.3)
+      '@remotion/layout-utils':
+        specifier: 4.0.512
+        version: 4.0.512
+      '@remotion/media':
+        specifier: 4.0.512
+        version: 4.0.512(react-dom@19.2.8(react@19.2.8))(react@19.2.8)
       react:
         specifier: ^19.0.0
         version: 19.2.8
@@ -381,6 +387,9 @@ packages:
     cpu: [x64]
     os: [win32]
 
+  '@remotion/layout-utils@4.0.512':
+    resolution: {integrity: sha512-ZJpRRQ54UHGrTW4g3/mzwfTftaXK779SXM5TOXnhS2Bh4JaImmDfvK1cUGIJu4lAOgMZsvLva+E6SqjzDt1qiw==}
+
   '@remotion/licensing@4.0.512':
     resolution: {integrity: sha512-TRDcdvgQXOxC12A/hu1VlTzt9CqIQr2RrhlL9kODgbqOEjefK1fS4EJY+PsmpxBcQqTI4+pw3KHbo9NkddPLfg==}
 
@@ -393,6 +402,12 @@ packages:
       react: '>=16.8.0'
       react-dom: '>=16.8.0'
 
+  '@remotion/media@4.0.512':
+    resolution: {integrity: sha512-/VmCY0D0KiXXqjQGOy2Mh/CtG9gPRpbWsIin/g/oBbosFNpWGYRSAB9gL+6wx4mPHeonSGMCyJMKyXVmm83FeQ==}
+    peerDependencies:
+      react: '>=16.8.0'
+      react-dom: '>=16.8.0'
+
   '@remotion/player@4.0.512':
     resolution: {integrity: sha512-Brc+aqjIyEEkwLncTNMrQf8MkfS/HhOSJs7qpDfK68nqOu/u3ULOtdIIXGPArvS3TkSea1FUA2VxP+1vqXwY2g==}
     peerDependencies:
@@ -1668,6 +1683,8 @@ snapshots:
   '@remotion/compositor-win32-x64-msvc@4.0.512':
     optional: true
 
+  '@remotion/layout-utils@4.0.512': {}
+
   '@remotion/licensing@4.0.512': {}
 
   '@remotion/media-parser@4.0.512': {}
@@ -1679,6 +1696,14 @@ snapshots:
       react-dom: 19.2.8(react@19.2.8)
       remotion: 4.0.512(react-dom@19.2.8(react@19.2.8))(react@19.2.8)
 
+  '@remotion/media@4.0.512(react-dom@19.2.8(react@19.2.8))(react@19.2.8)':
+    dependencies:
+      mediabunny: 1.50.8
+      react: 19.2.8
+      react-dom: 19.2.8(react@19.2.8)
+      remotion: 4.0.512(react-dom@19.2.8(react@19.2.8))(react@19.2.8)
+      zod: 4.4.3
+
   '@remotion/player@4.0.512(react-dom@19.2.8(react@19.2.8))(react@19.2.8)':
     dependencies:
       react: 19.2.8
diff --git a/media/self-evolving-coding-agents-video/video/remotion.config.ts b/media/self-evolving-coding-agents-video/video/remotion.config.ts
index dcbd61570..a5b5e8e5c 100644
--- a/media/self-evolving-coding-agents-video/video/remotion.config.ts
+++ b/media/self-evolving-coding-agents-video/video/remotion.config.ts
@@ -1,4 +1,14 @@
 import {Config} from '@remotion/cli/config';
 
-Config.setVideoImageFormat('jpeg');
+Config.setVideoImageFormat('jpeg'); // jpeg 显著快于 png（无透明需求）
 Config.setOverwriteOutput(true);
+// —— 交付硬化（B 站/YouTube）——
+Config.setCodec('h264'); // 平台通吃；h265 经平台二压反而更差
+Config.setCrf(18); // h264 视觉无损档
+Config.setPixelFormat('yuv420p'); // 兼容基线（yuv444p 部分解码器不支持）
+Config.setAudioCodec('aac');
+Config.setAudioBitrate('192K'); // 单人旁白透明
+Config.setEnforceAudioTrack(true); // 缺音频也出静音轨，防平台拒收无音轨文件
+Config.setJpegQuality(90); // 终渲；草渲由 CLI --jpeg-quality=60 覆盖
+// 注意：不设 setConcurrency——并发度是机器属性，写入三集共享文件正是要消灭的
+// 漂移类型；渲染主机应先 npx remotion benchmark 再以 CLI --concurrency=N 传入。
diff --git a/media/self-evolving-coding-agents-video/video/src/Main.tsx b/media/self-evolving-coding-agents-video/video/src/Main.tsx
index d4bf8632b..d29e9aa02 100644
--- a/media/self-evolving-coding-agents-video/video/src/Main.tsx
+++ b/media/self-evolving-coding-agents-video/video/src/Main.tsx
@@ -1,9 +1,10 @@
 import React from 'react';
 import {AbsoluteFill, Sequence} from 'remotion';
 import {NarrationAudio} from './components/NarrationAudio';
+import {SceneFade} from './components/SceneFade';
 import {Subtitle} from './components/Subtitle';
 import {theme} from './design/theme';
-import {computeTimeline} from './timing';
+import {computeTimeline, SCENE_FADE_FRAMES} from './timing';
 import type {ManifestItem, SceneRange} from './types';
 import {P0Hook} from './scenes/P0Hook';
 import {P1Boundary} from './scenes/P1Boundary';
@@ -29,14 +30,17 @@ export const Main: React.FC<MainProps> = ({manifest}) => {
   const {timed, scenes} = computeTimeline(manifest);
   return (
     <AbsoluteFill style={{background: theme.bg}}>
-      {scenes.map((sc) => {
+      {scenes.map((sc, i) => {
         const SceneComp = SCENE_COMPONENTS[sc.scene];
         if (!SceneComp) {
           throw new Error(`未注册的场景组件: ${sc.scene}`);
         }
         return (
           <Sequence key={sc.scene} from={sc.from} durationInFrames={sc.durationInFrames} name={sc.scene}>
-            <SceneComp scene={sc} />
+            {/* 幕间呼吸淡入淡出：只花幕间既有静默，from/总时长零改动 */}
+            <SceneFade durationInFrames={sc.durationInFrames} fadeIn={i === 0 ? 0 : SCENE_FADE_FRAMES} fadeOut={i === scenes.length - 1 ? 0 : SCENE_FADE_FRAMES}>
+              <SceneComp scene={sc} />
+            </SceneFade>
           </Sequence>
         );
       })}
diff --git a/media/self-evolving-coding-agents-video/video/src/components/NarrationAudio.tsx b/media/self-evolving-coding-agents-video/video/src/components/NarrationAudio.tsx
index 0555863f4..3f7a04132 100644
--- a/media/self-evolving-coding-agents-video/video/src/components/NarrationAudio.tsx
+++ b/media/self-evolving-coding-agents-video/video/src/components/NarrationAudio.tsx
@@ -1,16 +1,30 @@
 import React from 'react';
-import {Audio, Sequence, staticFile} from 'remotion';
+import {Audio} from '@remotion/media';
+import {staticFile} from 'remotion';
 import type {TimedSentence} from '../types';
 
-/** 全片旁白：每句一段音频，按 manifest 时序装配 */
-export const NarrationAudio: React.FC<{timed: TimedSentence[]}> = ({timed}) => {
-  return (
-    <>
-      {timed.map((s) => (
-        <Sequence key={s.id} from={s.from} durationInFrames={s.durationInFrames} name={`audio:${s.id}`}>
-          <Audio src={staticFile(`audio/${s.id}.mp3`)} />
-        </Sequence>
-      ))}
-    </>
-  );
-};
+/**
+ * 预览期提前 1s 挂载缓冲；渲染期 Remotion 自动关闭 premount（active 含
+ * !env.isRendering——收益只在 Studio 拖拽与 Player，渲染侧收益是 Mediabunny
+ * 抽轨与官方声明的时间轴同步，不是渲染速度。见 skills/06 事实条）。
+ */
+const PREMOUNT_FRAMES = 30;
+
+/** 全片旁白：每句一段音频，按 manifest 绝对帧位装配（时间轴与视觉层解耦）。
+ *  @remotion/media 的 <Audio> 原生带 from/durationInFrames，无须外包 <Sequence>——
+ *  premountFor 挂在「尚未开始的 Sequence」子节点上不会触发。失败默认回落
+ *  <Html5Audio>（更稳），缺 manifest 的报错在 Root.tsx calculateMetadata。 */
+export const NarrationAudio: React.FC<{timed: TimedSentence[]}> = ({timed}) => (
+  <>
+    {timed.map((s) => (
+      <Audio
+        key={s.id}
+        name={`audio:${s.id}`}
+        src={staticFile(`audio/${s.id}.mp3`)}
+        from={s.from}
+        durationInFrames={s.durationInFrames}
+        premountFor={PREMOUNT_FRAMES}
+      />
+    ))}
+  </>
+);
diff --git a/media/self-evolving-coding-agents-video/video/src/components/SceneFade.tsx b/media/self-evolving-coding-agents-video/video/src/components/SceneFade.tsx
new file mode 100644
index 000000000..6e7bc20d7
--- /dev/null
+++ b/media/self-evolving-coding-agents-video/video/src/components/SceneFade.tsx
@@ -0,0 +1,41 @@
+import React from 'react';
+import {AbsoluteFill, interpolate, useCurrentFrame} from 'remotion';
+
+/**
+ * 幕间呼吸淡入淡出——只花 timing.json 已声明的幕间静默（句间 0.32s + 幕间 0.9s），
+ * 不改任何 Sequence 的 from 与总时长，音频层零风险。
+ *
+ * 为什么不用 @remotion/transitions 的 TransitionSeries：其总时长 = Σ序列 − Σ转场，
+ * 会把视觉层整体左移而旁白（按 manifest 帧号绝对定位的独立层）不动，产生逐幕
+ * 递增的失同步。见 media/pipeline/skills/06-remotion-implementation.md。
+ *
+ * 用法（Main.tsx 的 scenes.map 内包一层）：
+ *   <SceneFade durationInFrames={sc.durationInFrames}
+ *              fadeIn={i === 0 ? 0 : SCENE_FADE_FRAMES}
+ *              fadeOut={i === scenes.length - 1 ? 0 : SCENE_FADE_FRAMES}>
+ *     <SceneComp scene={sc} />
+ *   </SceneFade>
+ * 首幕不淡入（LEAD_IN 0.6s 本就黑场）；末幕不淡出（尾幕渐黑由 P6 从末 beat 推导，
+ * 叠加会成双重渐黑——上线教训见 skills/06 清单第 4 条）。
+ * 三集逐字节一致（冻结清单成员）。不变式由 check_script.py 强制：
+ * 2 × sceneCrossFadeSec ≤ sentenceGapSec + sceneGapSec。
+ */
+export const SceneFade: React.FC<{
+  durationInFrames: number;
+  fadeIn: number;
+  fadeOut: number;
+  children: React.ReactNode;
+}> = ({durationInFrames, fadeIn, fadeOut, children}) => {
+  const frame = useCurrentFrame();
+  const inOp = fadeIn
+    ? interpolate(frame, [0, fadeIn], [0, 1], {extrapolateRight: 'clamp'})
+    : 1;
+  const outOp = fadeOut
+    ? interpolate(frame, [durationInFrames - fadeOut, durationInFrames], [1, 0], {
+        extrapolateLeft: 'clamp',
+      })
+    : 1;
+  return (
+    <AbsoluteFill style={{opacity: Math.min(inOp, outOp)}}>{children}</AbsoluteFill>
+  );
+};
diff --git a/media/self-evolving-coding-agents-video/video/src/components/Subtitle.tsx b/media/self-evolving-coding-agents-video/video/src/components/Subtitle.tsx
index ac3b4b78a..d34a3f3df 100644
--- a/media/self-evolving-coding-agents-video/video/src/components/Subtitle.tsx
+++ b/media/self-evolving-coding-agents-video/video/src/components/Subtitle.tsx
@@ -1,14 +1,21 @@
 import React from 'react';
 import {AbsoluteFill, interpolate, useCurrentFrame} from 'remotion';
+import {fitText} from '@remotion/layout-utils';
 import {theme} from '../design/theme';
 import type {TimedSentence} from '../types';
 
-const CJK = /[⺀-鿿豈-﫿]/;
-/** 全角标点与 CJK 同宽（1em），不满足 CJK 区间，须并列判定；
- *  ASCII 引号 (U+0022/27) 字形实为半宽，不入此类、按 0.55 桶计 */
-const FULLWIDTH_PUNCT = /[，。！？：；、“”‘’（）——…·《》「」]/;
+const MAX_WIDTH = 1600;
+const PADDING_X = 36;
+/** Remotion 默认样式表为 box-sizing: border-box，内容预算须减去左右 padding */
+const CONTENT_WIDTH = MAX_WIDTH - PADDING_X * 2;
+const MAX_FONT_SIZE = 44;
+const MIN_FONT_SIZE = 30;
 
-/** 全片底部字幕条：一句一条，与配音逐句同步（storyboard.md 字幕规范） */
+/** 全片底部字幕条：一句一条，与配音逐句同步（storyboard.md 字幕规范）。
+ *  字号用 @remotion/layout-utils 的 fitText 真实测量（替代此前手写的全角 1.0/半角
+ *  0.55 宽度估算与魔法阈值）。validateFontIsLoaded 保持 4.x 默认 false——系统字体
+ *  栈无 loadFont() promise 可等；⚠️ Remotion 5.0 起该开关默认翻 true，届时若仍未
+ *  内嵌字体会开始抛错（重启触发器见 pipeline/README 字体约束节）。 */
 export const Subtitle: React.FC<{timed: TimedSentence[]}> = ({timed}) => {
   const frame = useCurrentFrame();
   const current = timed.find((s) => frame >= s.from && frame < s.from + s.durationInFrames);
@@ -19,21 +26,20 @@ export const Subtitle: React.FC<{timed: TimedSentence[]}> = ({timed}) => {
   const opacity = interpolate(local, [0, 4], [0, 1], {
     extrapolateRight: 'clamp',
   });
-  // 长句防御性收缩：估算宽度超限时缩小字号，保证单行不溢出（全角≈1 字宽，半角≈0.55）。
-  // 内容预算 = maxWidth 1600 − 左右 padding 72 = 1528，估算含 ~2% 字距余量故用 1500 触发
-  const estWidth =
-    current.text.split('').reduce(
-      (w, ch) => w + (CJK.test(ch) || FULLWIDTH_PUNCT.test(ch) ? 1 : 0.55),
-      0,
-    ) * 44;
-  const fontSize = estWidth > 1500 ? Math.max(30, 44 - (estWidth - 1500) / 25) : 44;
+  const fitted = fitText({
+    text: current.text,
+    withinWidth: CONTENT_WIDTH,
+    fontFamily: theme.sans,
+    fontWeight: 500, // 须与下方 div 的 fontWeight 一致，否则测量偏小
+  }).fontSize;
+  const fontSize = Math.max(MIN_FONT_SIZE, Math.min(MAX_FONT_SIZE, fitted));
   return (
     <AbsoluteFill style={{justifyContent: 'flex-end', alignItems: 'center', pointerEvents: 'none'}}>
       <div
         style={{
           marginBottom: 54,
-          maxWidth: 1600,
-          padding: '12px 36px',
+          maxWidth: MAX_WIDTH,
+          padding: `12px ${PADDING_X}px`,
           borderRadius: 12,
           background: 'rgba(6, 8, 12, 0.68)',
           color: theme.text,
diff --git a/media/self-evolving-coding-agents-video/video/src/scenes/P6Ending.tsx b/media/self-evolving-coding-agents-video/video/src/scenes/P6Ending.tsx
index 4258a7cee..97330c03c 100644
--- a/media/self-evolving-coding-agents-video/video/src/scenes/P6Ending.tsx
+++ b/media/self-evolving-coding-agents-video/video/src/scenes/P6Ending.tsx
@@ -101,13 +101,12 @@ const OpenQuestion: React.FC = () => {
   );
 };
 
-/** 6-C 系列三卡 */
+/** 6-C 系列三卡（顺序与 media/series.json 对齐；本集高亮由 self 标志驱动，非位置耦合） */
 const SeriesThree: React.FC = () => {
-  const frame = useCurrentFrame();
   const eps = [
-    {title: 'AI 如何自己变强？', sub: '自我进化 · 改什么', c1: '#4A9EFF', c2: '#FF9F45', ep: '第一集'},
-    {title: '上线之后，AI 才开始上学', sub: '经验 · 怎么攒', c1: '#F5C542', c2: '#2DD4BF', ep: '第二集'},
-    {title: '会写代码的 AI，开始给自己写代码', sub: '代码田野 · 全图', c1: '#4ADE80', c2: '#FF6EC7', ep: '第三集 · 本集'},
+    {title: '上线之后，AI 才开始上学', sub: '经验 · 怎么攒', c1: '#F5C542', c2: '#2DD4BF', ep: '第一集', self: false},
+    {title: 'AI 如何自己变强？', sub: '自我进化 · 改什么', c1: '#4A9EFF', c2: '#FF9F45', ep: '第二集', self: false},
+    {title: '会写代码的 AI，开始给自己写代码', sub: '代码田野 · 全图', c1: '#4ADE80', c2: '#FF6EC7', ep: '第三集 · 本集', self: true},
   ];
   return (
     <AbsoluteFill style={{justifyContent: 'center', alignItems: 'center'}}>
@@ -120,8 +119,8 @@ const SeriesThree: React.FC = () => {
                 padding: '30px 26px',
                 borderRadius: 16,
                 background: theme.panel,
-                border: `2px solid ${i === 2 ? theme.text : theme.panelBorder}`,
-                boxShadow: i === 2 ? `0 0 44px ${theme.codeDeep}` : 'none',
+                border: `2px solid ${ep.self ? theme.text : theme.panelBorder}`,
+                boxShadow: ep.self ? `0 0 44px ${theme.codeDeep}` : 'none',
                 textAlign: 'center',
               }}
             >
@@ -144,7 +143,7 @@ const SeriesThree: React.FC = () => {
       </div>
       <FadeUp delay={70}>
         <div style={{marginTop: 50, fontFamily: theme.sans, fontSize: 28, color: theme.text}}>
-          三块拼图：改什么 → 怎么攒 → <span style={{color: theme.code, fontWeight: 700}}>代码领域全图</span>
+          三块拼图：怎么攒 → 改什么 → <span style={{color: theme.code, fontWeight: 700}}>代码领域全图</span>
         </div>
       </FadeUp>
     </AbsoluteFill>
diff --git a/media/self-evolving-coding-agents-video/video/src/timing.json b/media/self-evolving-coding-agents-video/video/src/timing.json
new file mode 100644
index 000000000..1090a53bf
--- /dev/null
+++ b/media/self-evolving-coding-agents-video/video/src/timing.json
@@ -0,0 +1,8 @@
+{
+  "fps": 30,
+  "sentenceGapSec": 0.32,
+  "sceneGapSec": 0.9,
+  "leadInSec": 0.6,
+  "tailSec": 2.0,
+  "sceneCrossFadeSec": 0.4
+}
diff --git a/media/self-evolving-coding-agents-video/video/src/timing.ts b/media/self-evolving-coding-agents-video/video/src/timing.ts
index 8bf6f2a54..6d2379ada 100644
--- a/media/self-evolving-coding-agents-video/video/src/timing.ts
+++ b/media/self-evolving-coding-agents-video/video/src/timing.ts
@@ -1,14 +1,19 @@
 import type {ManifestItem, SceneRange, TimedSentence} from './types';
+import constants from './timing.json';
 
-export const FPS = 30;
+/** 时序常量单一事实源：本目录 timing.json（qa_frames.py / captions.py 读同一文件，
+ *  双语言镜像由此消灭；本集要调节奏只改 timing.json，不动代码） */
+export const FPS = constants.fps;
 /** 句间停顿 */
-const SENTENCE_GAP_SEC = 0.32;
+const SENTENCE_GAP_SEC = constants.sentenceGapSec;
 /** 幕间额外停顿（转场呼吸） */
-const SCENE_GAP_SEC = 0.9;
+const SCENE_GAP_SEC = constants.sceneGapSec;
 /** 片头静默引导 */
-const LEAD_IN_SEC = 0.6;
+const LEAD_IN_SEC = constants.leadInSec;
 /** 片尾静默淡出 */
-const TAIL_SEC = 2.0;
+const TAIL_SEC = constants.tailSec;
+/** 幕间呼吸淡入淡出帧数（见 components/SceneFade.tsx；首幕不淡入、末幕不淡出） */
+export const SCENE_FADE_FRAMES = Math.round(constants.sceneCrossFadeSec * constants.fps);
 
 export function computeTimeline(manifest: ManifestItem[]): {
   timed: TimedSentence[];
diff --git a/media/self-improving-agents-video/README.md b/media/self-improving-agents-video/README.md
index 06e862263..38cea4f32 100644
--- a/media/self-improving-agents-video/README.md
+++ b/media/self-improving-agents-video/README.md
@@ -25,10 +25,9 @@
 # 1. 改稿后重建逐句 JSON
 uv run --no-project scripts/build_narration.py
 
-# 2. 合成配音（本人音色克隆，增量幂等；需先启动 IndexTTS 服务，见 ../../pipeline/VOICE-CLONING.md）
-uv run --no-project --with mutagen scripts/tts.py --engine indextts \
-    --ref <仓库绝对路径>/media/pipeline/voices/me-1.wav --style passionate
-#    （声音样本不入库：me-1.wav 需从本人录音经 prepare_ref.py 裁剪生成；整集约数小时，断点续跑）
+# 2. 合成配音（本人音色克隆，增量幂等；参数读自本集 pipeline.toml（复现已上线音频的档：passionate + me-1.wav）；
+#    需先启动 IndexTTS 服务，见 ../pipeline/VOICE-CLONING.md）
+uv run --no-project ../pipeline/scripts/pipeline.py --project . tts
 
 # 3. 预览
 cd video && pnpm install --ignore-workspace && pnpm dev
@@ -55,4 +54,4 @@ cd video && pnpm run render               # -> ../out/final.mp4
 
 ## 许可注意
 
-Remotion 对超过 3 人的公司需商业授权（个人/小团队免费）；若本视频转为公司用途，请评估许可或迁移 MIT 协议的 Motion Canvas。配音为**本人声音的自愿克隆**（IndexTTS-2.5，按 bilibili 模型使用许可：个人/研究用途可用，商用需联系 indexspeech@bilibili.com；克隆他人声音须获本人书面同意，详见 [../../pipeline/VOICE-CLONING.md](../../pipeline/VOICE-CLONING.md) §八）。发布前请自行确认平台对合成语音的标注要求。
+Remotion 对超过 3 人的公司需商业授权（个人/小团队免费）；若本视频转为公司用途，请评估许可或迁移 MIT 协议的 Motion Canvas。配音为**本人声音的自愿克隆**（IndexTTS-2.5，按 bilibili 模型使用许可：个人/研究用途可用，商用需联系 indexspeech@bilibili.com；克隆他人声音须获本人书面同意，详见 [../pipeline/VOICE-CLONING.md](../pipeline/VOICE-CLONING.md) §八）。发布前请自行确认平台对合成语音的标注要求。
diff --git a/media/self-improving-agents-video/pipeline.toml b/media/self-improving-agents-video/pipeline.toml
new file mode 100644
index 000000000..645446f83
--- /dev/null
+++ b/media/self-improving-agents-video/pipeline.toml
@@ -0,0 +1,25 @@
+# 《AI 如何自己变强？》管线配置——pipeline.py 的默认参数源。
+# 可执行参数只落此处，README 不再复制粘贴命令行（防 ISSUE-161 类漂移）；
+# CLI 显式参数仍可覆盖本文件。
+
+[episode]
+slug  = "self-improving-agents-video"
+title = "AI 如何自己变强？"
+
+[narration]
+target_minutes = [15.0, 18.0]
+chars_per_min  = 280
+
+[tts]
+# ⚠️ 本配置记录的是「复现已上线音频」的档：三集成片统一 passionate + me-1.wav。
+# 摘要含 style 与 ref_sha1，改档 = 整集重合成（须 --allow-voice-switch 显式放行）。
+# 升级 sunny-steady 属独立重录决策，登记于 media/series.json 的待升级项。
+engine   = "indextts"
+ref      = "media/pipeline/voices/me-1.wav"
+ref_sha1 = "3ed0d9d60d4b"
+style    = "passionate"
+lang     = "ZH"
+
+[render]
+draft_scale        = 0.5
+draft_jpeg_quality = 60
diff --git a/media/self-improving-agents-video/script/storyboard.md b/media/self-improving-agents-video/script/storyboard.md
index 46e9df20d..8d50b4d52 100644
--- a/media/self-improving-agents-video/script/storyboard.md
+++ b/media/self-improving-agents-video/script/storyboard.md
@@ -20,8 +20,8 @@
 | 镜 | 句区间 | 画面 | 动效 |
 |---|---|---|---|
 | 1-A 提问 | p1-01..03 | 居中机器人轮廓线稿；"大脑 + 装备"两词分列蓝/橙 | 线稿描边生长 |
-| 1-B 大脑 | p1-04 | 头部亮起蓝色神经网络脉冲 | 脉冲波传导 |
-| 1-C 四件套 | p1-05..11 | 眼镜→笔记本→工具箱→守则依次装配到机器人身上，每件配橙色标签（提示词/记忆/工具/控制逻辑）；末句浮出 "Agent Harness" 术语标签 | 逐件飞入装配 + 标签弹出 |
+| 1-B 大脑 | p1-04..04b | 头部亮起蓝色神经网络脉冲 | 脉冲波传导 |
+| 1-C 四件套 | p1-05..10 | 眼镜→笔记本→工具箱→守则依次装配到机器人身上，每件配橙色标签（提示词/记忆/工具/控制逻辑）；末句浮出 "Agent Harness" 术语标签 | 逐件飞入装配 + 标签弹出 |
 | 1-D 公式彩蛋 | p1-11 尾 | 右下角微光浮现 A=(θ,Σ)，Σ=(p,m,𝒯,g) | 淡入 |
 | 1-E 草稿纸 | p1-12..14 | 机器人手边草稿纸写满字 → 揉团抛入纸篓 | 揉纸 + 抛物线 |
 | 1-F 定义卡 | p1-15..17 | 金句卡："自我进化 = 把经验变成【持久】的升级"，"持久"描红下划线 | 下划线扫描 |
@@ -32,13 +32,19 @@
 | 镜 | 句区间 | 画面 | 动效 |
 |---|---|---|---|
 | 2-A 章头 | p2-01..04 | 蓝色章节卡"第一条路：改大脑"；大脑图标 + "训练"进度条 | 章节转场 |
-| 2-B 功法一 | p2-05..13 | 出题循环图：模型→[生成题目]→[筛选]→[训练]→回到模型；Self-Instruct 雪球滚大、Evol-Instruct 难度条上升、STaR 只留 ✓ 的解法、"考场现学"闪现小考卷 | 循环流转 + 各方法小图标依次点亮 |
+| 2-B 功法一·雪球 | p2-05..07 | 出题循环图：模型→[生成题目]→[筛选]→[训练]→回到模型；Self-Instruct 雪球滚大 | 循环流转 |
+| 2-B2 功法一·进阶 | p2-08..09 | Evol-Instruct 难度条上升 | 难度条爬升 |
+| 2-B3 功法一·STaR | p2-10 | STaR 只留 ✓ 的解法 | 解法过滤 |
+| 2-B4 功法一·现学 | p2-11..13 | "考场现学"闪现小考卷 | 考卷闪现 |
 | 2-C 风险一 | p2-14..18 | 画面转红调：循环图歪斜，模型镜像越来越扭曲；字卡"模型坍缩" | 色调渐变 + 镜像扭曲 |
-| 2-D 功法二 | p2-19..26 | 模型分身：左"选手"右"裁判"；宪法卷轴展开逐条打钩；套娃动画——裁判身后浮现更大裁判（Meta-Rewarding） | 分身 + 卷轴 + 套娃层叠 |
+| 2-D 功法二·宪法 | p2-19..23 | 模型分身：左"选手"右"裁判"；宪法卷轴展开逐条打钩 | 分身 + 卷轴 |
+| 2-D2 功法二·套娃 | p2-24..26 | 套娃动画——裁判身后浮现更大裁判（Meta-Rewarding） | 套娃层叠 |
 | 2-E 投票 | p2-27..29 | 同一道题 N 个答案卡片落下，柱状图统计，最高柱加冕"标准答案"（TTRL） | 卡片下落 + 柱状图生长 |
 | 2-F 风险二 | p2-30..33 | 红调金句卡："一致 ≠ 正确"；一百个相同的错误答案整齐排列成方阵；英文书名卡 *Too consistent to detect* | 方阵复制粒子 |
-| 2-G 药方 | p2-34..37 | 三条药方列表逐条亮起：裁判选手分家 / 人类锚点 / 分歧=不确定性 | 列表逐项点亮 |
-| 2-H 功法三 | p2-38..43 | AI 走出"闭门修炼"圆圈，撞向标着"真实世界"的墙；单元测试红绿灯：✓ 绿 ✗ 红；网页操作场景配"打分模型"小裁判 | 出圈 + 红绿灯闪烁 |
+| 2-G 药方 | p2-34..37b | 三条药方列表逐条亮起：裁判选手分家 / 人类锚点 / 分歧=不确定性 | 列表逐项点亮 |
+| 2-H 功法三·出圈 | p2-38..39b | AI 走出"闭门修炼"圆圈，撞向标着"真实世界"的墙 | 出圈撞击 |
+| 2-H2 功法三·考场 | p2-40..41 | 单元测试红绿灯：✓ 绿 ✗ 红 | 红绿灯闪烁 |
+| 2-H3 功法三·裁判 | p2-42..43 | 网页操作场景配"打分模型"小裁判 | 裁判打分 |
 | 2-I 世界模型 | p2-44..48 | 梦境泡泡包裹驾驶舱，AI 在泡泡里练车，里程数飞涨 | 泡泡浮动 + 计数器滚动 |
 | 2-J 风险三 | p2-49..51 | 泡泡边缘失真、出现不存在的三条腿行人剪影；出泡泡前过"验证"闸门 | 失真波纹 + 闸门 |
 
@@ -46,18 +52,18 @@
 
 | 镜 | 句区间 | 画面 | 动效 |
 |---|---|---|---|
-| 3-A 章头 | p3-01..05 | 橙色章节卡"第二条路：改装备"；四层阶梯自下而上亮起：眼镜/笔记本/工具箱/全身 | 阶梯逐层点亮 |
+| 3-A 章头 | p3-01..05b | 橙色章节卡"第二条路：改装备"；四层阶梯自下而上亮起：眼镜/笔记本/工具箱/全身 | 阶梯逐层点亮 |
 | 3-B 换眼镜 | p3-06..08 | 眼镜特写，镜片上提示词文本流动；换镜片 → 世界配色改变 | 镜片切换 + 世界重着色 |
 | 3-C 提示进化史 | p3-09..15 | 四阶段横向时间轴：打分(仅数字)→评语(红笔批注)→种群进化(基因双螺旋+杂交)→TextGrad(文本梯度箭头沿链路反传) | 时间轴推进 |
 | 3-D 金句 | p3-16..17 | 金句卡："反馈越具体，机器越不用靠猜"；"玄学→工程学"天平倾斜 | 天平动画 |
-| 3-E 记笔记 | p3-18..24 | 笔记本翻页；四动作依次盖章：记(蒸馏漏斗)/翻(知识图谱连线跳跃)/改(降权刻度)/忘(碎纸机) | 盖章 + 各小动画 |
+| 3-E 记笔记 | p3-18..24c | 笔记本翻页；四动作依次盖章：记(蒸馏漏斗)/翻(知识图谱连线跳跃)/改(降权刻度)/忘(碎纸机) | 盖章 + 各小动画 |
 | 3-F 记忆毛病 | p3-25..29 | "近因偏差"：时间轴只有最近段高亮，关键往事灰暗；"相似≠有用"：检索出一排相似卡片全部打 ✗ | 高亮对比 |
 | 3-G Voyager | p3-30..34c | 像素风 Minecraft 小剧场：方块机器人对着树写代码 → 弹出"砍树程序 v1"卡片 ✓ → 存入"技能库"书架 → 再遇树秒调用；p3-34b/c 时书架卡片翻面显示「技能 = 打包保存的一次自我升级」金句条 | 像素动画 + 书架收纳 + 金句条翻面 |
 | 3-H 工具闭环 | p3-35..42 | 三节点循环图：选（路由分叉）→修（扳手+隔离区）→造（新工具铸造+验证+注册）；金句浮条"推进能力边界，而不只是在边界内干活" | 循环流转 |
 | 3-I 改造整套装备 | p3-43..48 | 莫比乌斯环上一段代码在改写自己；黏土揉捏（"mutable substrate·可变基质"角标）；p3-44b 大脑保持蓝色不动，橙色部分全部流动 | 环面流动 + 黏土形变 |
 | 3-J 后代树 | p3-50..53 | Darwin Gödel Machine 进化树：节点分叉，每个节点过"测试"小闸；弱枝不删除、灰色保留在"档案库"栏内，多路并行延伸 | 树生长 + 档案库收纳 |
 | 3-K 开船修船 | p3-54..57 | 船在行驶中被机械臂改造，扳手本身也在变形 | 船体改造 + 扳手形变 |
-| 3-L 验证门 | p3-58..62 | 改动队列过三重闸机（单元测试/回归/安全），不合格弹回；"回滚"按钮特写 | 闸机放行/弹回 |
+| 3-L 验证门 | p3-58..62b | 改动队列过三重闸机（单元测试/回归/安全），不合格弹回；"回滚"按钮特写 | 闸机放行/弹回 |
 
 ## P4 平衡与安全（约 110s）
 
diff --git a/media/self-improving-agents-video/video/package.json b/media/self-improving-agents-video/video/package.json
index d411d185e..425279d55 100644
--- a/media/self-improving-agents-video/video/package.json
+++ b/media/self-improving-agents-video/video/package.json
@@ -10,6 +10,8 @@
   },
   "dependencies": {
     "@remotion/cli": "^4.0.0",
+    "@remotion/layout-utils": "4.0.512",
+    "@remotion/media": "4.0.512",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
     "remotion": "^4.0.0"
diff --git a/media/self-improving-agents-video/video/pnpm-lock.yaml b/media/self-improving-agents-video/video/pnpm-lock.yaml
index 7d5af9af2..2d6ac110e 100644
--- a/media/self-improving-agents-video/video/pnpm-lock.yaml
+++ b/media/self-improving-agents-video/video/pnpm-lock.yaml
@@ -11,6 +11,12 @@ importers:
       '@remotion/cli':
         specifier: ^4.0.0
         version: 4.0.512(postcss@8.5.26)(react-dom@19.2.8(react@19.2.8))(react@19.2.8)(supports-color@8.1.1)(typescript@5.9.3)
+      '@remotion/layout-utils':
+        specifier: 4.0.512
+        version: 4.0.512
+      '@remotion/media':
+        specifier: 4.0.512
+        version: 4.0.512(react-dom@19.2.8(react@19.2.8))(react@19.2.8)
       react:
         specifier: ^19.0.0
         version: 19.2.8
@@ -381,6 +387,9 @@ packages:
     cpu: [x64]
     os: [win32]
 
+  '@remotion/layout-utils@4.0.512':
+    resolution: {integrity: sha512-ZJpRRQ54UHGrTW4g3/mzwfTftaXK779SXM5TOXnhS2Bh4JaImmDfvK1cUGIJu4lAOgMZsvLva+E6SqjzDt1qiw==}
+
   '@remotion/licensing@4.0.512':
     resolution: {integrity: sha512-TRDcdvgQXOxC12A/hu1VlTzt9CqIQr2RrhlL9kODgbqOEjefK1fS4EJY+PsmpxBcQqTI4+pw3KHbo9NkddPLfg==}
 
@@ -393,6 +402,12 @@ packages:
       react: '>=16.8.0'
       react-dom: '>=16.8.0'
 
+  '@remotion/media@4.0.512':
+    resolution: {integrity: sha512-/VmCY0D0KiXXqjQGOy2Mh/CtG9gPRpbWsIin/g/oBbosFNpWGYRSAB9gL+6wx4mPHeonSGMCyJMKyXVmm83FeQ==}
+    peerDependencies:
+      react: '>=16.8.0'
+      react-dom: '>=16.8.0'
+
   '@remotion/player@4.0.512':
     resolution: {integrity: sha512-Brc+aqjIyEEkwLncTNMrQf8MkfS/HhOSJs7qpDfK68nqOu/u3ULOtdIIXGPArvS3TkSea1FUA2VxP+1vqXwY2g==}
     peerDependencies:
@@ -1668,6 +1683,8 @@ snapshots:
   '@remotion/compositor-win32-x64-msvc@4.0.512':
     optional: true
 
+  '@remotion/layout-utils@4.0.512': {}
+
   '@remotion/licensing@4.0.512': {}
 
   '@remotion/media-parser@4.0.512': {}
@@ -1679,6 +1696,14 @@ snapshots:
       react-dom: 19.2.8(react@19.2.8)
       remotion: 4.0.512(react-dom@19.2.8(react@19.2.8))(react@19.2.8)
 
+  '@remotion/media@4.0.512(react-dom@19.2.8(react@19.2.8))(react@19.2.8)':
+    dependencies:
+      mediabunny: 1.50.8
+      react: 19.2.8
+      react-dom: 19.2.8(react@19.2.8)
+      remotion: 4.0.512(react-dom@19.2.8(react@19.2.8))(react@19.2.8)
+      zod: 4.4.3
+
   '@remotion/player@4.0.512(react-dom@19.2.8(react@19.2.8))(react@19.2.8)':
     dependencies:
       react: 19.2.8
diff --git a/media/self-improving-agents-video/video/remotion.config.ts b/media/self-improving-agents-video/video/remotion.config.ts
index dcbd61570..a5b5e8e5c 100644
--- a/media/self-improving-agents-video/video/remotion.config.ts
+++ b/media/self-improving-agents-video/video/remotion.config.ts
@@ -1,4 +1,14 @@
 import {Config} from '@remotion/cli/config';
 
-Config.setVideoImageFormat('jpeg');
+Config.setVideoImageFormat('jpeg'); // jpeg 显著快于 png（无透明需求）
 Config.setOverwriteOutput(true);
+// —— 交付硬化（B 站/YouTube）——
+Config.setCodec('h264'); // 平台通吃；h265 经平台二压反而更差
+Config.setCrf(18); // h264 视觉无损档
+Config.setPixelFormat('yuv420p'); // 兼容基线（yuv444p 部分解码器不支持）
+Config.setAudioCodec('aac');
+Config.setAudioBitrate('192K'); // 单人旁白透明
+Config.setEnforceAudioTrack(true); // 缺音频也出静音轨，防平台拒收无音轨文件
+Config.setJpegQuality(90); // 终渲；草渲由 CLI --jpeg-quality=60 覆盖
+// 注意：不设 setConcurrency——并发度是机器属性，写入三集共享文件正是要消灭的
+// 漂移类型；渲染主机应先 npx remotion benchmark 再以 CLI --concurrency=N 传入。
diff --git a/media/self-improving-agents-video/video/src/Main.tsx b/media/self-improving-agents-video/video/src/Main.tsx
index 1a0eab0a8..96cf4b7c5 100644
--- a/media/self-improving-agents-video/video/src/Main.tsx
+++ b/media/self-improving-agents-video/video/src/Main.tsx
@@ -1,9 +1,10 @@
 import React from 'react';
 import {AbsoluteFill, Sequence} from 'remotion';
 import {NarrationAudio} from './components/NarrationAudio';
+import {SceneFade} from './components/SceneFade';
 import {Subtitle} from './components/Subtitle';
 import {theme} from './design/theme';
-import {computeTimeline} from './timing';
+import {computeTimeline, SCENE_FADE_FRAMES} from './timing';
 import type {ManifestItem, SceneRange} from './types';
 import {P0Cold} from './scenes/P0Cold';
 import {P1Anatomy} from './scenes/P1Anatomy';
@@ -27,14 +28,17 @@ export const Main: React.FC<MainProps> = ({manifest}) => {
   const {timed, scenes} = computeTimeline(manifest);
   return (
     <AbsoluteFill style={{background: theme.bg}}>
-      {scenes.map((sc) => {
+      {scenes.map((sc, i) => {
         const SceneComp = SCENE_COMPONENTS[sc.scene];
         if (!SceneComp) {
           throw new Error(`未注册的场景组件: ${sc.scene}`);
         }
         return (
           <Sequence key={sc.scene} from={sc.from} durationInFrames={sc.durationInFrames} name={sc.scene}>
-            <SceneComp scene={sc} />
+            {/* 幕间呼吸淡入淡出：只花幕间既有静默，from/总时长零改动 */}
+            <SceneFade durationInFrames={sc.durationInFrames} fadeIn={i === 0 ? 0 : SCENE_FADE_FRAMES} fadeOut={i === scenes.length - 1 ? 0 : SCENE_FADE_FRAMES}>
+              <SceneComp scene={sc} />
+            </SceneFade>
           </Sequence>
         );
       })}
diff --git a/media/self-improving-agents-video/video/src/components/NarrationAudio.tsx b/media/self-improving-agents-video/video/src/components/NarrationAudio.tsx
index 0555863f4..3f7a04132 100644
--- a/media/self-improving-agents-video/video/src/components/NarrationAudio.tsx
+++ b/media/self-improving-agents-video/video/src/components/NarrationAudio.tsx
@@ -1,16 +1,30 @@
 import React from 'react';
-import {Audio, Sequence, staticFile} from 'remotion';
+import {Audio} from '@remotion/media';
+import {staticFile} from 'remotion';
 import type {TimedSentence} from '../types';
 
-/** 全片旁白：每句一段音频，按 manifest 时序装配 */
-export const NarrationAudio: React.FC<{timed: TimedSentence[]}> = ({timed}) => {
-  return (
-    <>
-      {timed.map((s) => (
-        <Sequence key={s.id} from={s.from} durationInFrames={s.durationInFrames} name={`audio:${s.id}`}>
-          <Audio src={staticFile(`audio/${s.id}.mp3`)} />
-        </Sequence>
-      ))}
-    </>
-  );
-};
+/**
+ * 预览期提前 1s 挂载缓冲；渲染期 Remotion 自动关闭 premount（active 含
+ * !env.isRendering——收益只在 Studio 拖拽与 Player，渲染侧收益是 Mediabunny
+ * 抽轨与官方声明的时间轴同步，不是渲染速度。见 skills/06 事实条）。
+ */
+const PREMOUNT_FRAMES = 30;
+
+/** 全片旁白：每句一段音频，按 manifest 绝对帧位装配（时间轴与视觉层解耦）。
+ *  @remotion/media 的 <Audio> 原生带 from/durationInFrames，无须外包 <Sequence>——
+ *  premountFor 挂在「尚未开始的 Sequence」子节点上不会触发。失败默认回落
+ *  <Html5Audio>（更稳），缺 manifest 的报错在 Root.tsx calculateMetadata。 */
+export const NarrationAudio: React.FC<{timed: TimedSentence[]}> = ({timed}) => (
+  <>
+    {timed.map((s) => (
+      <Audio
+        key={s.id}
+        name={`audio:${s.id}`}
+        src={staticFile(`audio/${s.id}.mp3`)}
+        from={s.from}
+        durationInFrames={s.durationInFrames}
+        premountFor={PREMOUNT_FRAMES}
+      />
+    ))}
+  </>
+);
diff --git a/media/self-improving-agents-video/video/src/components/SceneFade.tsx b/media/self-improving-agents-video/video/src/components/SceneFade.tsx
new file mode 100644
index 000000000..6e7bc20d7
--- /dev/null
+++ b/media/self-improving-agents-video/video/src/components/SceneFade.tsx
@@ -0,0 +1,41 @@
+import React from 'react';
+import {AbsoluteFill, interpolate, useCurrentFrame} from 'remotion';
+
+/**
+ * 幕间呼吸淡入淡出——只花 timing.json 已声明的幕间静默（句间 0.32s + 幕间 0.9s），
+ * 不改任何 Sequence 的 from 与总时长，音频层零风险。
+ *
+ * 为什么不用 @remotion/transitions 的 TransitionSeries：其总时长 = Σ序列 − Σ转场，
+ * 会把视觉层整体左移而旁白（按 manifest 帧号绝对定位的独立层）不动，产生逐幕
+ * 递增的失同步。见 media/pipeline/skills/06-remotion-implementation.md。
+ *
+ * 用法（Main.tsx 的 scenes.map 内包一层）：
+ *   <SceneFade durationInFrames={sc.durationInFrames}
+ *              fadeIn={i === 0 ? 0 : SCENE_FADE_FRAMES}
+ *              fadeOut={i === scenes.length - 1 ? 0 : SCENE_FADE_FRAMES}>
+ *     <SceneComp scene={sc} />
+ *   </SceneFade>
+ * 首幕不淡入（LEAD_IN 0.6s 本就黑场）；末幕不淡出（尾幕渐黑由 P6 从末 beat 推导，
+ * 叠加会成双重渐黑——上线教训见 skills/06 清单第 4 条）。
+ * 三集逐字节一致（冻结清单成员）。不变式由 check_script.py 强制：
+ * 2 × sceneCrossFadeSec ≤ sentenceGapSec + sceneGapSec。
+ */
+export const SceneFade: React.FC<{
+  durationInFrames: number;
+  fadeIn: number;
+  fadeOut: number;
+  children: React.ReactNode;
+}> = ({durationInFrames, fadeIn, fadeOut, children}) => {
+  const frame = useCurrentFrame();
+  const inOp = fadeIn
+    ? interpolate(frame, [0, fadeIn], [0, 1], {extrapolateRight: 'clamp'})
+    : 1;
+  const outOp = fadeOut
+    ? interpolate(frame, [durationInFrames - fadeOut, durationInFrames], [1, 0], {
+        extrapolateLeft: 'clamp',
+      })
+    : 1;
+  return (
+    <AbsoluteFill style={{opacity: Math.min(inOp, outOp)}}>{children}</AbsoluteFill>
+  );
+};
diff --git a/media/self-improving-agents-video/video/src/components/Subtitle.tsx b/media/self-improving-agents-video/video/src/components/Subtitle.tsx
index ac3b4b78a..d34a3f3df 100644
--- a/media/self-improving-agents-video/video/src/components/Subtitle.tsx
+++ b/media/self-improving-agents-video/video/src/components/Subtitle.tsx
@@ -1,14 +1,21 @@
 import React from 'react';
 import {AbsoluteFill, interpolate, useCurrentFrame} from 'remotion';
+import {fitText} from '@remotion/layout-utils';
 import {theme} from '../design/theme';
 import type {TimedSentence} from '../types';
 
-const CJK = /[⺀-鿿豈-﫿]/;
-/** 全角标点与 CJK 同宽（1em），不满足 CJK 区间，须并列判定；
- *  ASCII 引号 (U+0022/27) 字形实为半宽，不入此类、按 0.55 桶计 */
-const FULLWIDTH_PUNCT = /[，。！？：；、“”‘’（）——…·《》「」]/;
+const MAX_WIDTH = 1600;
+const PADDING_X = 36;
+/** Remotion 默认样式表为 box-sizing: border-box，内容预算须减去左右 padding */
+const CONTENT_WIDTH = MAX_WIDTH - PADDING_X * 2;
+const MAX_FONT_SIZE = 44;
+const MIN_FONT_SIZE = 30;
 
-/** 全片底部字幕条：一句一条，与配音逐句同步（storyboard.md 字幕规范） */
+/** 全片底部字幕条：一句一条，与配音逐句同步（storyboard.md 字幕规范）。
+ *  字号用 @remotion/layout-utils 的 fitText 真实测量（替代此前手写的全角 1.0/半角
+ *  0.55 宽度估算与魔法阈值）。validateFontIsLoaded 保持 4.x 默认 false——系统字体
+ *  栈无 loadFont() promise 可等；⚠️ Remotion 5.0 起该开关默认翻 true，届时若仍未
+ *  内嵌字体会开始抛错（重启触发器见 pipeline/README 字体约束节）。 */
 export const Subtitle: React.FC<{timed: TimedSentence[]}> = ({timed}) => {
   const frame = useCurrentFrame();
   const current = timed.find((s) => frame >= s.from && frame < s.from + s.durationInFrames);
@@ -19,21 +26,20 @@ export const Subtitle: React.FC<{timed: TimedSentence[]}> = ({timed}) => {
   const opacity = interpolate(local, [0, 4], [0, 1], {
     extrapolateRight: 'clamp',
   });
-  // 长句防御性收缩：估算宽度超限时缩小字号，保证单行不溢出（全角≈1 字宽，半角≈0.55）。
-  // 内容预算 = maxWidth 1600 − 左右 padding 72 = 1528，估算含 ~2% 字距余量故用 1500 触发
-  const estWidth =
-    current.text.split('').reduce(
-      (w, ch) => w + (CJK.test(ch) || FULLWIDTH_PUNCT.test(ch) ? 1 : 0.55),
-      0,
-    ) * 44;
-  const fontSize = estWidth > 1500 ? Math.max(30, 44 - (estWidth - 1500) / 25) : 44;
+  const fitted = fitText({
+    text: current.text,
+    withinWidth: CONTENT_WIDTH,
+    fontFamily: theme.sans,
+    fontWeight: 500, // 须与下方 div 的 fontWeight 一致，否则测量偏小
+  }).fontSize;
+  const fontSize = Math.max(MIN_FONT_SIZE, Math.min(MAX_FONT_SIZE, fitted));
   return (
     <AbsoluteFill style={{justifyContent: 'flex-end', alignItems: 'center', pointerEvents: 'none'}}>
       <div
         style={{
           marginBottom: 54,
-          maxWidth: 1600,
-          padding: '12px 36px',
+          maxWidth: MAX_WIDTH,
+          padding: `12px ${PADDING_X}px`,
           borderRadius: 12,
           background: 'rgba(6, 8, 12, 0.68)',
           color: theme.text,
diff --git a/media/self-improving-agents-video/video/src/timing.json b/media/self-improving-agents-video/video/src/timing.json
new file mode 100644
index 000000000..1090a53bf
--- /dev/null
+++ b/media/self-improving-agents-video/video/src/timing.json
@@ -0,0 +1,8 @@
+{
+  "fps": 30,
+  "sentenceGapSec": 0.32,
+  "sceneGapSec": 0.9,
+  "leadInSec": 0.6,
+  "tailSec": 2.0,
+  "sceneCrossFadeSec": 0.4
+}
diff --git a/media/self-improving-agents-video/video/src/timing.ts b/media/self-improving-agents-video/video/src/timing.ts
index 8bf6f2a54..6d2379ada 100644
--- a/media/self-improving-agents-video/video/src/timing.ts
+++ b/media/self-improving-agents-video/video/src/timing.ts
@@ -1,14 +1,19 @@
 import type {ManifestItem, SceneRange, TimedSentence} from './types';
+import constants from './timing.json';
 
-export const FPS = 30;
+/** 时序常量单一事实源：本目录 timing.json（qa_frames.py / captions.py 读同一文件，
+ *  双语言镜像由此消灭；本集要调节奏只改 timing.json，不动代码） */
+export const FPS = constants.fps;
 /** 句间停顿 */
-const SENTENCE_GAP_SEC = 0.32;
+const SENTENCE_GAP_SEC = constants.sentenceGapSec;
 /** 幕间额外停顿（转场呼吸） */
-const SCENE_GAP_SEC = 0.9;
+const SCENE_GAP_SEC = constants.sceneGapSec;
 /** 片头静默引导 */
-const LEAD_IN_SEC = 0.6;
+const LEAD_IN_SEC = constants.leadInSec;
 /** 片尾静默淡出 */
-const TAIL_SEC = 2.0;
+const TAIL_SEC = constants.tailSec;
+/** 幕间呼吸淡入淡出帧数（见 components/SceneFade.tsx；首幕不淡入、末幕不淡出） */
+export const SCENE_FADE_FRAMES = Math.round(constants.sceneCrossFadeSec * constants.fps);
 
 export function computeTimeline(manifest: ManifestItem[]): {
   timed: TimedSentence[];
diff --git a/media/series.json b/media/series.json
new file mode 100644
index 000000000..ae1506ea4
--- /dev/null
+++ b/media/series.json
@@ -0,0 +1,76 @@
+{
+  "series": {
+    "id": "self-evolution",
+    "title": "自进化系列科普视频",
+    "rule": "各集独立成片。口播文本严禁出现其他集标题、集数序号或「上一集/上期/第 N 集」等顺序词；序号只存在于视觉层与本文件，据此保证发布顺序变更的 TTS 代价为零（「下期再见」一类顺序无关的收尾语不受此限）。校验器：media/pipeline/scripts/check_series.py。"
+  },
+  "episodes": [
+    {
+      "episode": 1,
+      "slug": "experience-era-agents-video",
+      "path": "media/experience-era-agents-video",
+      "title": "上线之后，AI 才开始上学",
+      "topic": "部署之后经验怎么攒",
+      "cardSub": "经验 · 怎么攒",
+      "accents": [
+        "#F5C542",
+        "#2DD4BF",
+        "#B78CFF"
+      ],
+      "paper": {
+        "title": "Self-Improving Agents in the Era of Experience: A Survey of Self- to Meta-Evolution",
+        "id": null,
+        "idNote": "无公开 arXiv 号（引用卡写机构+日期，不编造编号）",
+        "venue": "清华大学 × Horizon Research (Frontis.AI)",
+        "date": "2026-06"
+      },
+      "status": "ready",
+      "statusNote": "v3 已完成：内容校准（187 句，25 改写 + 8 新增）+ sunny-steady 全片重配 + 终渲 14:01；源码含未重渲改动（P3 Figure 8 格阵落格校准，见 PR 说明），发布前须重渲",
+      "voice": "sunny-steady + me-bright.wav（2026-08 重录决策）"
+    },
+    {
+      "episode": 2,
+      "slug": "self-improving-agents-video",
+      "path": "media/self-improving-agents-video",
+      "title": "AI 如何自己变强？",
+      "topic": "自我进化改什么",
+      "cardSub": "自我进化 · 改什么",
+      "accents": [
+        "#4A9EFF",
+        "#FF9F45"
+      ],
+      "paper": {
+        "title": "Self-Improvements in Modern Agentic Systems: A Survey",
+        "id": "arXiv:2607.13104",
+        "idNote": "",
+        "venue": "吉林大学 × KAUST × Alberta × IDSIA（Schmidhuber 团队）",
+        "date": "2026-07"
+      },
+      "status": "ready",
+      "statusNote": "待升级项：换 sunny-steady 重配（机器空闲口径约 2–3h，未排期；旧 10h 为忙时实测，见 VOICE-CLONING §4.3b 复测）",
+      "voice": "passionate + me-1.wav（已上线成片所用）"
+    },
+    {
+      "episode": 3,
+      "slug": "self-evolving-coding-agents-video",
+      "path": "media/self-evolving-coding-agents-video",
+      "title": "会写代码的 AI，开始给自己写代码",
+      "topic": "代码领域全图",
+      "cardSub": "代码田野 · 全图",
+      "accents": [
+        "#4ADE80",
+        "#FF6EC7"
+      ],
+      "paper": {
+        "title": "Self-Evolving Coding Agents: A Survey",
+        "id": "arXiv:2608.03392",
+        "idNote": "",
+        "venue": "南京理工大学 × 南京大学",
+        "date": "2026-08"
+      },
+      "status": "ready",
+      "statusNote": "源码含未重渲改动（系列三卡重排，见 PR 说明）；待升级项：换 sunny-steady 重配",
+      "voice": "passionate + me-1.wav（已上线成片所用）"
+    }
+  ]
+}
diff --git a/media/series.md b/media/series.md
new file mode 100644
index 000000000..2f191e62a
--- /dev/null
+++ b/media/series.md
@@ -0,0 +1,14 @@
+# 自进化系列科普视频（作品总览）
+
+> 机读 SSOT：[series.json](./series.json)（顺序变更只改它 + 视觉层；口播永不携带序号，
+> 校验器 [check_series.py](./pipeline/scripts/check_series.py) 保证散文/组件与清单一致）。
+
+| # | 作品 | 一句话主题 | 视觉契约（主色） | 源论文 | 状态 |
+|---|---|---|---|---|---|
+| 1 | [《上线之后，AI 才开始上学》](./experience-era-agents-video/README.md) | 部署之后经验怎么攒 | 金/青/紫 | 清华×Frontis 88 页综述（无 arXiv 号），2026-06 | **v3 就绪**（内容校准 + sunny-steady 全片重配，成片 14:01；源码含未重渲改动：P3 格阵落格校准） |
+| 2 | [《AI 如何自己变强？》](./self-improving-agents-video/README.md) | 自我进化改什么 | 蓝/橙 | arXiv:2607.13104（Schmidhuber 团队），2026-07 | 就绪（待升级 sunny-steady，未排期） |
+| 3 | [《会写代码的 AI，开始给自己写代码》](./self-evolving-coding-agents-video/README.md) | 代码领域全图 | 绿/洋红 | arXiv:2608.03392（NJUST×NJU），2026-08 | 就绪（源码含未重渲改动；待升级 sunny-steady） |
+
+**系列纪律**：各集独立成片，口播互不引用、不出现集数序号——顺序只存在于本清单与片尾视觉卡片，发布顺序变更的 TTS 代价恒为零。
+
+制作走 [公共管线](./pipeline/README.md)（九阶段）；配音经 IndexTTS-2.5 本人音色克隆（样本指纹见 [voices/refs.toml](./pipeline/voices/refs.toml)，手册 [VOICE-CLONING.md](./pipeline/VOICE-CLONING.md)）。