diff --git a/AGENTS.md b/AGENTS.md
index d06fa84..e71d539 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -43,10 +43,10 @@
 | 风格 | 从立意推出来，可以参考 `styles/` 的预设，写明借了什么 | 写在每张立意卡的"画面"一行（专属，或借一个预设）；选卡就一起定了，人可以在回复里换 | 同左；每张卡的草图就是那种风格的小样，借来的预设人想看时在 E0 补小样 |
 | 分镜 | 简表：镜头、时长、reads | 完整 STORYBOARD + 分镜预览图 | 同左 + animatic |
 | 自查 | 整片一张联系表、一张按目标屏缩的联系表、前 2 s 的 strip，20 条清单速查一遍 | 每个场景：联系表、关键动作 strip、局部 crop；20 条清单 | 同左，再加目标屏尺寸测试、循环接缝、无损帧确定性、静默故障扫描 |
-| 独立评审（打分层） | 不做 | 1 轮：全新上下文的 reviewer 打 8 项分（含立意），修最差的 3 处 | ≥ 3 轮，8 项都 ≥ 8 才出片；达不到就带着分数进关卡 ③ |
+| 独立评审（打分层） | 不做 | 1 轮：全新上下文的 reviewer 打 8 项分（含立意），修最差的 3 处，改过的段落做局部复查 | ≥ 3 轮、最多 10 轮，8 项都 ≥ 8 才出片；同一类问题最多改 5 次，小修只做局部复查；到上限还没过线，就带着分数进关卡 ③ |
 | 声音 | 可以没有，或一段配乐 / 配音加基础混音 | 配乐或配音 + 关键动作音效 + 按视频类型的混音 profile（`bin/vh mix … profile=`）+ `bin/vh qa` | 同左 + 每个动作的拟音和声像 + 最终混音 cue check + 混音报告（`bin/vh qa mix`）没有硬失败 |
 | 渲染与交付 | draft 画质即可，一个 mp4 | 正式画质 mp4 + 联系表 | 同左 + 网页版、GIF、封面，按需出 9:16 |
-| draft 版数 | 1–2 版 | 一般 3–5 版 | 不设上限，直到过线 |
+| draft 版数 | 1–2 版 | 一般 3–5 版 | 不设上限，直到过线（整片评审的轮数另有上限，见"独立评审"一行） |
 | subagent | 不用 | 长片按章节并行 | 并行制作 + 独立评审，按需加作曲 subagent |
 | 参考研究 | 只读类型文档 | + 类型文档列的案例 | + 拉片参考（`playbook/07`）、深读 `references/` |
 | 大致耗时（30 s 左右的片子） | 10–30 分钟 | 1–2 小时 | 3 小时以上 |
@@ -54,18 +54,20 @@
 
 最后一行是给能调推理强度的 agent 的建议（例如 Claude Code 选模型时的 effort 档位），不能调就忽略。
 
+**评审有上限**：整片评审（全新上下文的 reviewer 看完整片、打满 8 项分）一支片子最多 10 轮；同一类问题（同一条清单条目落在同一个镜头或段落上）最多改 5 次，改不动就写进 NOTES 的"已知局限"交给人；一条标签的时间、一个音效的音量这类小修，只查改过的那一段，不为它重开整片评审。后一轮在口味条目上推翻前一轮时，可以保留前一轮的决定，在 `DECISIONS.md` 记一行为什么。细则见 `TASTE_CHECKLIST.md` 的打分层。
+
 **任何档位都不降的底线**：
 - 硬规则 1（每一帧是 t 的纯函数）、5（事实照抄原文）、7（不在文件里写 key）；
 - 片中不出现数字静音（管有声片；用户要的无声片不带音轨，不适用）；
 - 全屏闪白每秒不超过 3 次；
 - 字号不低于 BRIEF"在哪看"那一档的下限（`playbook/03-motion-design.md` §4）；
 - 素材许可要记清；
-- `TASTE_CHECKLIST.md` 里标【底线】的条目：安全框、读时、字号、字不被光烧白、reads 不被盖掉、循环接缝、分镜里声明的卡点、没有占位和编造；
+- `TASTE_CHECKLIST.md` 里标【底线】的条目：安全框、读时（够快读一遍；从容多少跟 BRIEF 的 `Pace` 走，是口味）、字号、字不被光烧白、reads 不被盖掉、循环接缝、分镜里声明的卡点、没有占位和编造；
 - 出片前跑一次 `bin/vh check`。
 
 `quick` 省掉的是轮数和审阅，不是这些。
 
-**底线之外都是默认口味**：`TASTE_CHECKLIST.md` 里没标【底线】的条目、BRIEF 的 Motion defaults、类型文档 Prompt 增量块里的语域和节拍、镜头配方，都是没有立意时的稳妥做法。风格预设只是参考：借了什么在 `DECISIONS.md` 记一行，不借、借一半、几个混着借都行，和它不一样不用解释；借来的东西碰到清单里没标【底线】的条目，照口味覆盖记一行。立意需要时可以反着来：在写用到它的场景之前，把改了什么、立意为什么需要写在立意卡或 STYLE.md 上，记进 `DECISIONS.md`；人批过的卡上写了的，算人的决定，reviewer 只查有没有做到；之后才加的由 reviewer 判断站不站得住，判了 FAIL 再补的不算（`playbook/12-ideation.md` 第 6 节）。类型文档"禁止"一节也分两种：管事实、许可、可读和隐私的是底线，管长相的（配色、质感、缓动、图表样式）是默认口味。规则是用来防止犯错的，不是用来规定口味的。
+**底线之外都是默认口味**：`TASTE_CHECKLIST.md` 里没标【底线】的条目、BRIEF 的 Motion defaults 和 `Pace`、类型文档 Prompt 增量块里的语域和节拍、镜头配方，都是没有立意时的稳妥做法。风格预设只是参考：借了什么在 `DECISIONS.md` 记一行，不借、借一半、几个混着借都行，和它不一样不用解释；借来的东西碰到清单里没标【底线】的条目，照口味覆盖记一行。立意需要时可以反着来：在写用到它的场景之前，把改了什么、立意为什么需要写在立意卡或 STYLE.md 上，记进 `DECISIONS.md`；人批过的卡上写了的，算人的决定，reviewer 只查有没有做到；之后才加的由 reviewer 判断站不站得住，判了 FAIL 再补的不算（`playbook/12-ideation.md` 第 6 节）。类型文档"禁止"一节也分两种：管事实、许可、可读和隐私的是底线，管长相的（配色、质感、缓动、图表样式）是默认口味。规则是用来防止犯错的，不是用来规定口味的。
 
 ## 导演模式：谁来拍板
 
@@ -129,7 +131,7 @@ effort 管 agent 自己查得多细，导演模式管人拍板哪些事，两个
 1. **每一帧都是 t 的纯函数。** 不用 `Math.random()`、`Date.now()`、CSS transition 或 `@keyframes`，不保存跨帧状态；需要随机时用带种子的 `hash(i)`。乱序渲染同一帧，结果必须一致。检验方法：从中间抽几帧单独渲染，和整片里的同一帧比对，要逐像素相同；如果 GPU 光栅化带来细微差异，PSNR 至少 45 dB，而且肉眼看不出。比的是无损 PNG 帧，不是编码后的 mp4（x264 会放大差异）。
 2. **有声音时，音频决定时长。** 先生成配音或拿到歌曲，转成词级时间戳和节拍表，再用实测时长回写分镜，让画面去对齐音频。静音视频的时长由分镜里的 reads 决定，画面必须在静音下读得懂。
 3. **先分镜后代码。** 分镜里给每个镜头写出观众必须依次看懂的 reads，并标起止时间；重要的 reads 不能重叠。
-4. **每个场景都要自查。** 至少包括：一张联系表，关键动作一条逐帧 strip，承载剧情的脸或细节一个 crop；对照 `TASTE_CHECKLIST.md`，发现问题就修。整片 draft 还要过清单里的打分层：换一个严苛的 reviewer 按 8 个维度（含立意）打分，每项都要 ≥ 8。自查成本很低，不要省。
+4. **每个场景都要自查。** 至少包括：一张联系表，关键动作一条逐帧 strip，承载剧情的脸或细节一个 crop；对照 `TASTE_CHECKLIST.md`，发现问题就修。整片 draft 还要过清单里的打分层：换一个严苛的 reviewer 按 8 个维度（含立意）打分，每项都要 ≥ 8；轮数有上限，小修只查改过的那一段（见上面的"评审有上限"）。自查成本很低，不要省。
 5. **事实有纪律。** 论文元数据、数字、引文一律照抄原文；拿不准的写进 `NOTES.md`，不编进视频。
 6. **只在 `projects/` 里改东西。** `engines/` 是模板，`references/repos/` 是只读参考；需要时复制到自己的项目里再改。
 7. **不在文件里写 API key。** 一律从环境变量读取；缺 key 时告诉用户需要哪个。
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 58f3758..4381b6e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,13 @@
 
 ## Unreleased
 
+**Review rounds have caps; reading time follows the film's pace instead of fixed seconds**
+- Why: a `studio` film's independent review ran 11 full rounds: each fresh reviewer found new taste nits, the scores hovered at 7–9, and small fixes sometimes broke something else. The maintainer: "我觉得可以了 其实我觉得也不必要你每次这么十几轮审阅 太多了 给项目加一个限制，每一种问题不超过5次，总共不超过10次，不要为了一个小问题就全部来一遍Review。另外，项目中关于字的节奏也不要写死间隔时间，有的时候太慢。"
+- Review caps (`templates/TASTE_CHECKLIST.md`'s scoring layer; CLAUDE.md / AGENTS.md: the effort table and a new 评审有上限 paragraph; playbook/01 and 02; both READMEs; `templates/NOTES.md` and `REVIEW.md`; video-types/09). A film gets at most 10 full review rounds (a fresh-context reviewer scoring all eight dimensions over the whole film); then it ships, or the scores go to the human at gate ③. The same kind of issue (one checklist item on one shot or segment) gets at most 5 fix-and-check cycles, then goes into NOTES as a known limitation with its last evidence, for the human to decide. A local fix (one label's timing or size, a safe-frame nudge, an SFX level, one shot's layout) is checked on its own span: its frames and strips, the automated checks that cover it, the author's look; a new full round is for structural changes or the last pass. The minimums stay (standard 1 round; studio at least 3, all eight at 8 or above, and those three rounds run even when only small fixes happen in between). When the human sends a film back at gate ③ with new notes, both counts restart. A 【底线】 item still failing at its cap goes to the human; until they decide, nothing ships as final, and an unattended run labels its output "has a floor FAIL, not a release". When a later round contradicts an earlier one on a taste item, the author may keep the earlier decision with a line in DECISIONS. NOTES gets 评审记录 (one line a round), a 问题计数 table and 已知局限; the reviewer is given the known limitations so it stops re-raising them. `bin/vh effort standard|studio` prints the caps.
+- Reading time has no fixed seconds. The floor (TASTE_CHECKLIST #5, 【底线】) is one brisk read: max(1.5 s, CJK/7 + other/20 + 0.8 s), which is #53's short-label rule (the intro film was cut to it), now for all on-screen text. The comfortable target is a taste default set by a new BRIEF line, `- Pace: relaxed | normal | brisk` (default normal): relaxed CJK/4.5 + other/15 + 1.0 s, normal CJK/6 + other/18 + 0.8 s, brisk CJK/7 + other/20 + 0.8 s, which is the floor (the 8 CJK/s + 0.3 s first proposed for brisk sat under the floor at every length). Text the viewer already knows and short labels may run at brisk; text on a musical grid ends on a bar line instead of being padded. playbook/03 §2 explains the numbers; the old 2.5 s minimum and 1.5 s pad are gone; labels (`data-read="label"`) target the floor.
+- `tools/readcheck.py`: the pace comes from `--pace`, else the nearest BRIEF.md's Pace line, else normal. Under the floor is a FAIL (exit 1), under the target only a WARN (exit 0); lines read OK / WARN / FAIL (was OK / BAD). `data-pace` on a clip or scene (nearest wins, sub-compositions included) and `"pace"` in texts.json set the target for the texts under it, and `--export` writes it. `--mode label` and `data-read="label"` keep working and mean a brisk target. `--cjk-cps`, `--latin-cps`, `--pad` and `--min` still work and retune the target only. `--budget` gives the pace's target and the floor; `bin/vh readcheck -h` prints the rules. `bin/vh rhythm` draws under-the-floor texts red and under-the-target ones amber. `bin/vh new` writes `- Pace: relaxed` for math and paper projects and `brisk` for meme, normal otherwise. CI covers the WARN band, the floor and its 1.5 s minimum, the BRIEF's Pace, `--pace`, a bad pace, and a new project's Pace line.
+- Docs that restated 2.5 s now follow the rule: `templates/BRIEF.md` (Pace, Text rules), `templates/STORYBOARD.md`, video-types/01's prompt block, nine style presets, the recipes (black-card, breath-title-card and brand-imprint-open recomputed at normal: holds of 46, 62 and 45 frames, with their durations, QA frames and index rows; the sequence budgets say 读时 instead of ≥ 75 frames), `cases/promo-video-shotcraft.md`, and a current-state line in docs/research/04.
+
 **Docs: a Douyin case study, a landscape variant for knowledge films, and two ideation prompts**
 - Why: of ten AI-made Douyin films (nine posted in late September 2026, most tagged #vibe知识大赏), the four most-liked (148k–667k likes) are all 16:9 and 2.5–5 min long. Type 02 had described 30–90 s vertical films as the main case; Douyin landscape films appeared only in `cases/oneshot-five.md`.
 - `cases/douyin-vibe-knowledge.md` covers the ten films: post date, likes (a 10-04 snapshot), length, frame and opening. It also records:
diff --git a/CLAUDE.md b/CLAUDE.md
index 4dfe700..8fe0232 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -40,10 +40,10 @@
 | 风格 | 从立意推出来，可以参考 `styles/` 的预设，写明借了什么 | 写在每张立意卡的"画面"一行（专属，或借一个预设）；选卡就一起定了，人可以在回复里换 | 同左；每张卡的草图就是那种风格的小样，借来的预设人想看时在 E0 补小样 |
 | 分镜 | 简表：镜头、时长、reads | 完整 STORYBOARD + 分镜预览图 | 同左 + animatic |
 | 自查 | 整片一张联系表、一张按目标屏缩的联系表、前 2 s 的 strip，20 条清单速查一遍 | 每个场景：联系表、关键动作 strip、局部 crop；20 条清单 | 同左，再加目标屏尺寸测试、循环接缝、无损帧确定性、静默故障扫描 |
-| 独立评审（打分层） | 不做 | 1 轮：全新上下文的 reviewer 打 8 项分（含立意），修最差的 3 处 | ≥ 3 轮，8 项都 ≥ 8 才出片；达不到就带着分数进关卡 ③ |
+| 独立评审（打分层） | 不做 | 1 轮：全新上下文的 reviewer 打 8 项分（含立意），修最差的 3 处，改过的段落做局部复查 | ≥ 3 轮、最多 10 轮，8 项都 ≥ 8 才出片；同一类问题最多改 5 次，小修只做局部复查；到上限还没过线，就带着分数进关卡 ③ |
 | 声音 | 可以没有，或一段配乐 / 配音加基础混音 | 配乐或配音 + 关键动作音效 + 按视频类型的混音 profile（`bin/vh mix … profile=`）+ `bin/vh qa` | 同左 + 每个动作的拟音和声像 + 最终混音 cue check + 混音报告（`bin/vh qa mix`）没有硬失败 |
 | 渲染与交付 | draft 画质即可，一个 mp4 | 正式画质 mp4 + 联系表 | 同左 + 网页版、GIF、封面，按需出 9:16 |
-| draft 版数 | 1–2 版 | 一般 3–5 版 | 不设上限，直到过线 |
+| draft 版数 | 1–2 版 | 一般 3–5 版 | 不设上限，直到过线（整片评审的轮数另有上限，见"独立评审"一行） |
 | subagent | 不用 | 长片按章节并行 | 并行制作 + 独立评审，按需加作曲 subagent |
 | 参考研究 | 只读类型文档 | + 类型文档列的案例 | + 拉片参考（`playbook/07`）、深读 `references/` |
 | 大致耗时（30 s 左右的片子） | 10–30 分钟 | 1–2 小时 | 3 小时以上 |
@@ -51,18 +51,20 @@
 
 最后一行是给能调推理强度的 agent 的建议（例如 Claude Code 选模型时的 effort 档位），不能调就忽略。
 
+**评审有上限**：整片评审（全新上下文的 reviewer 看完整片、打满 8 项分）一支片子最多 10 轮；同一类问题（同一条清单条目落在同一个镜头或段落上）最多改 5 次，改不动就写进 NOTES 的"已知局限"交给人；一条标签的时间、一个音效的音量这类小修，只查改过的那一段，不为它重开整片评审。后一轮在口味条目上推翻前一轮时，可以保留前一轮的决定，在 `DECISIONS.md` 记一行为什么。细则见 `TASTE_CHECKLIST.md` 的打分层。
+
 **任何档位都不降的底线**：
 - 硬规则 1（每一帧是 t 的纯函数）、5（事实照抄原文）、7（不在文件里写 key）；
 - 片中不出现数字静音（管有声片；用户要的无声片不带音轨，不适用）；
 - 全屏闪白每秒不超过 3 次；
 - 字号不低于 BRIEF"在哪看"那一档的下限（`playbook/03-motion-design.md` §4）；
 - 素材许可要记清；
-- `TASTE_CHECKLIST.md` 里标【底线】的条目：安全框、读时、字号、字不被光烧白、reads 不被盖掉、循环接缝、分镜里声明的卡点、没有占位和编造；
+- `TASTE_CHECKLIST.md` 里标【底线】的条目：安全框、读时（够快读一遍；从容多少跟 BRIEF 的 `Pace` 走，是口味）、字号、字不被光烧白、reads 不被盖掉、循环接缝、分镜里声明的卡点、没有占位和编造；
 - 出片前跑一次 `bin/vh check`。
 
 `quick` 省掉的是轮数和审阅，不是这些。
 
-**底线之外都是默认口味**：`TASTE_CHECKLIST.md` 里没标【底线】的条目、BRIEF 的 Motion defaults、类型文档 Prompt 增量块里的语域和节拍、镜头配方，都是没有立意时的稳妥做法。风格预设只是参考：借了什么在 `DECISIONS.md` 记一行，不借、借一半、几个混着借都行，和它不一样不用解释；借来的东西碰到清单里没标【底线】的条目，照口味覆盖记一行。立意需要时可以反着来：在写用到它的场景之前，把改了什么、立意为什么需要写在立意卡或 STYLE.md 上，记进 `DECISIONS.md`；人批过的卡上写了的，算人的决定，reviewer 只查有没有做到；之后才加的由 reviewer 判断站不站得住，判了 FAIL 再补的不算（`playbook/12-ideation.md` 第 6 节）。类型文档"禁止"一节也分两种：管事实、许可、可读和隐私的是底线，管长相的（配色、质感、缓动、图表样式）是默认口味。规则是用来防止犯错的，不是用来规定口味的。
+**底线之外都是默认口味**：`TASTE_CHECKLIST.md` 里没标【底线】的条目、BRIEF 的 Motion defaults 和 `Pace`、类型文档 Prompt 增量块里的语域和节拍、镜头配方，都是没有立意时的稳妥做法。风格预设只是参考：借了什么在 `DECISIONS.md` 记一行，不借、借一半、几个混着借都行，和它不一样不用解释；借来的东西碰到清单里没标【底线】的条目，照口味覆盖记一行。立意需要时可以反着来：在写用到它的场景之前，把改了什么、立意为什么需要写在立意卡或 STYLE.md 上，记进 `DECISIONS.md`；人批过的卡上写了的，算人的决定，reviewer 只查有没有做到；之后才加的由 reviewer 判断站不站得住，判了 FAIL 再补的不算（`playbook/12-ideation.md` 第 6 节）。类型文档"禁止"一节也分两种：管事实、许可、可读和隐私的是底线，管长相的（配色、质感、缓动、图表样式）是默认口味。规则是用来防止犯错的，不是用来规定口味的。
 
 ## 导演模式：谁来拍板
 
@@ -126,7 +128,7 @@ effort 管 agent 自己查得多细，导演模式管人拍板哪些事，两个
 1. **每一帧都是 t 的纯函数。** 不用 `Math.random()`、`Date.now()`、CSS transition 或 `@keyframes`，不保存跨帧状态；需要随机时用带种子的 `hash(i)`。乱序渲染同一帧，结果必须一致。检验方法：从中间抽几帧单独渲染，和整片里的同一帧比对，要逐像素相同；如果 GPU 光栅化带来细微差异，PSNR 至少 45 dB，而且肉眼看不出。比的是无损 PNG 帧，不是编码后的 mp4（x264 会放大差异）。
 2. **有声音时，音频决定时长。** 先生成配音或拿到歌曲，转成词级时间戳和节拍表，再用实测时长回写分镜，让画面去对齐音频。静音视频的时长由分镜里的 reads 决定，画面必须在静音下读得懂。
 3. **先分镜后代码。** 分镜里给每个镜头写出观众必须依次看懂的 reads，并标起止时间；重要的 reads 不能重叠。
-4. **每个场景都要自查。** 至少包括：一张联系表，关键动作一条逐帧 strip，承载剧情的脸或细节一个 crop；对照 `TASTE_CHECKLIST.md`，发现问题就修。整片 draft 还要过清单里的打分层：换一个严苛的 reviewer 按 8 个维度（含立意）打分，每项都要 ≥ 8。自查成本很低，不要省。
+4. **每个场景都要自查。** 至少包括：一张联系表，关键动作一条逐帧 strip，承载剧情的脸或细节一个 crop；对照 `TASTE_CHECKLIST.md`，发现问题就修。整片 draft 还要过清单里的打分层：换一个严苛的 reviewer 按 8 个维度（含立意）打分，每项都要 ≥ 8；轮数有上限，小修只查改过的那一段（见上面的"评审有上限"）。自查成本很低，不要省。
 5. **事实有纪律。** 论文元数据、数字、引文一律照抄原文；拿不准的写进 `NOTES.md`，不编进视频。
 6. **只在 `projects/` 里改东西。** `engines/` 是模板，`references/repos/` 是只读参考；需要时复制到自己的项目里再改。
 7. **不在文件里写 API key。** 一律从环境变量读取；缺 key 时告诉用户需要哪个。
diff --git a/README.md b/README.md
index e725bff..ed62f98 100644
--- a/README.md
+++ b/README.md
@@ -206,7 +206,7 @@ Not every film deserves the full process. Say "quick draft" or "studio quality"
 |---|---|---|---|
 | For | trying a direction, drafts | most real videos | launches, flagship pieces |
 | Stops for you | none | three | three, plus a short sample of each direction and a full-length animatic |
-| Second-agent review | none | one round | at least three, all eight scores at 8 or above |
+| Second-agent review | none | one round | three to ten, all eight scores at 8 or above; a small fix is rechecked on its own span, not with a new round |
 | A 30-second film takes about | 10–30 min | 1–2 h | 3 h or more |
 
 At every level: no invented facts, no sudden silence in a film with sound, no rapid flashing, and type no smaller than the floor for the target screen.
diff --git a/README.zh-CN.md b/README.zh-CN.md
index cbef345..bc574ba 100644
--- a/README.zh-CN.md
+++ b/README.zh-CN.md
@@ -206,7 +206,7 @@ AI 听不见，所以声音尽量做成能计算、能测量的：
 |---|---|---|---|
 | 适合 | 试方向、草稿 | 大多数正式视频 | 发布片、旗舰内容 |
 | 停下来等你 | 不停，直接出片 | 三次 | 三次，另附每个创意方向的样片和全片动态分镜（animatic） |
-| 另一个 agent 打分 | 不打 | 1 轮 | 至少 3 轮，8 项都要 8 分以上 |
+| 另一个 agent 打分 | 不打 | 1 轮 | 3 到 10 轮，8 项都要 8 分以上；小修只复查改过的那一段，不重开一轮 |
 | 30 秒的片子大概要 | 10–30 分钟 | 1–2 小时 | 3 小时以上 |
 
 哪一档都不放松的：事实不编、有声片里没有突然的静音、画面不频闪、字不小于目标屏幕的下限。
diff --git a/bin/vh b/bin/vh
index 0bc788a..7999755 100755
--- a/bin/vh
+++ b/bin/vh
@@ -52,8 +52,9 @@
 #   mux <video> <audio> <out> [--subs-off] [subs.srt…]  audio track (+ soft zh/en subtitle tracks) onto a rendered video, moov first
 #                               (--subs-off: no subtitle track starts switched on, for a picture with burned-in captions)
 #  check
-#   readcheck <texts.json|project|index.html> [--mode onscreen|label|subtitle] [--lang zh|en]  on-screen text held long enough / subtitles within reading speed (exit 1 on fail);
-#                               a clip marked data-read="subtitle" (a caption that repeats the narration) is checked as a subtitle
+#   readcheck <texts.json|project|index.html> [--pace relaxed|normal|brisk] [--mode onscreen|label|subtitle] [--lang zh|en]  reading time, no fixed seconds:
+#                               FAIL under one brisk read (CJK/7 + other/20 + 0.8 s, at least 1.5 s; exit 1), WARN under the target of the BRIEF's
+#                               Pace (exit 0); subtitles within reading speed. data-read="subtitle"|"label" and data-pace="…" mark clips
 #                               readcheck --budget <s>: how many characters fit in a span · readcheck <index.html|project> --export [--out f]: the composition's timed text
 #   sheet <video> [cols] [fps] [out]  contact sheet (default: <project>/out/check/<name>-sheet-<HHMMSS>.png)
 #   check <video>               ffprobe + black/freeze/silence detection
@@ -378,6 +379,10 @@ PY
     sedi "s/^- Effort: standard /- Effort: $effort /" "$dir/BRIEF.md"
     [ "$effort" = quick ] && printf '\n> **Effort: quick**（%s，建项目时选定）：按 CLAUDE.md"努力程度"，人工关卡豁免，直接出片；人点名要拍板的事照样停（导演模式）；需求有歧义时最多问 1 个问题。\n' "$(date +%F)" >> "$dir/REVIEW.md"
   fi
+  case "$type" in   # the type's usual reading pace (the BRIEF's Pace comment); the BRIEF line can change it
+    math|paper) sedi "s/^- Pace: normal /- Pace: relaxed /" "$dir/BRIEF.md" ;;
+    meme) sedi "s/^- Pace: normal /- Pace: brisk /" "$dir/BRIEF.md" ;;
+  esac
   for s in $styles; do attach_style "$dir" "$s"; done   # presets as references: copies in style-refs/, listed in BRIEF, a DECISIONS line
   trap - EXIT
   echo "$c_ok created $(rel "$dir")"
@@ -412,6 +417,7 @@ for l in lines:
             rest = v[2:].lstrip("，,；; ")
             v = c[2] + ((" " if rest.startswith("+") else "；") + rest if rest else "")
         print(f"  {c[0]:<10} {v}")
+    elif l.startswith("**评审有上限") and lvl != "quick": print("\n" + l)   # quick has no review rounds
     elif l.startswith("**任何档位都不降"): print("\n" + l)
     elif l.startswith("- ") and "硬规则" in l or l.startswith("- 片中") or l.startswith("- 全屏") or l.startswith("- 字号") or l.startswith("- 素材") or l.startswith("- `TASTE_CHECKLIST") or l.startswith("- 出片前"): print("  " + l)
 ' "$lvl"
diff --git a/cases/promo-video-shotcraft.md b/cases/promo-video-shotcraft.md
index e52e0bc..0849440 100644
--- a/cases/promo-video-shotcraft.md
+++ b/cases/promo-video-shotcraft.md
@@ -65,7 +65,7 @@
 
 **改写时和本仓库规则对齐的地方**：
 
-- **读时规则更严**：它的字卡整张 1.8 s、字标停 1 s。本仓库要求没人念的画面文字从完整显示起至少停 max(2.5 s, 读时公式)（TASTE_CHECKLIST #5），所以改写后的字卡、黑场字卡、字标开场都变长了，骨架里的呼吸字卡也因此更少。
+- **读时规则更严**：它的字卡整张 1.8 s、字标停 1 s。本仓库当时要求没人念的画面文字从完整显示起至少停 max(2.5 s, 读时公式)（TASTE_CHECKLIST #5；2026-10-04 起改成底线够快读一遍、舒服的时长按 BRIEF 的 Pace），所以改写后的字卡、黑场字卡、字标开场都变长了，骨架里的呼吸字卡也因此更少。
 - **强调不用斜体**：它的字卡用"斜体 + 强调色"标重点词，本仓库改成字重或颜色（playbook/03 §4）。
 - **blur 只在 canvas 里动画**：DOM 里不动画 `blur`（playbook/03 §4），压印和虚焦的模糊放到 canvas 层。
 - **要读的小字至少 44 px**：它的副标、标语是 25–26 px 的装饰小字，改写后提到 1080p 的辅助文字下限。
diff --git a/docs/research/04-readability.md b/docs/research/04-readability.md
index eb24a06..7fb2f24 100644
--- a/docs/research/04-readability.md
+++ b/docs/research/04-readability.md
@@ -7,6 +7,7 @@
 > - **落地**：笔记里"在做"的那一块已经由 [#25](https://github.com/ZLHad/OpenVideoHarness/pull/25) 合并：[`tools/readcheck.py`](../../tools/readcheck.py) 能不开浏览器读 HyperFrames 合成文件（`bin/vh readcheck index.html`），按 HyperFrames 的规则解出每个片段的起止，项目自带 HyperFrames 时用它的 `timeline --json`；`--export` 把这份时间表写成 `texts.json` 供手改，`--budget <秒>` 先问一段时间放得下多少字。算不出时间的（解析不了的引用、脚本在整片长的片段里画的字）会列为"没检查"，不算通过。
 > - **介绍片**：它的文字是 Three.js 场景里的脚本逐帧画的，`index.html` 里没有文字片段，所以对它跑 `bin/vh readcheck showcase/04-intro-film/index.html` 只得到"没检查：没有找到文字"；那 63 条的窗口仍然是照 JS 公式重建的，下面"局限"的第一条没变。
 > - **没动的**：`showcase/04-intro-film` 在 main 上没有改动。
+> - **规则改了（2026-10-04）**：下文的 max(2.5 s, 汉字数 ÷ 4.5 + 其他字符数 ÷ 15 + 1.5 s) 不再是底线。底线改成够快读一遍：max(1.5 s, 汉字数 ÷ 7 + 其他字符数 ÷ 20 + 0.8 s)，就是 #53 的短标签规则，舒服的时长按 BRIEF 的 `Pace`（relaxed / normal / brisk），`readcheck` 低于底线报 FAIL、只低于目标报 WARN；见 [`playbook/03-motion-design.md`](../../playbook/03-motion-design.md) §2。下文的数字和图都是按旧规则算的。
 
 ## 问题
 
diff --git a/docs/research/en/04-readability.md b/docs/research/en/04-readability.md
index 074ba20..015d70f 100644
--- a/docs/research/en/04-readability.md
+++ b/docs/research/en/04-readability.md
@@ -7,6 +7,7 @@
 > - **Landed**: the part the note lists as "in progress" is merged in [#25](https://github.com/ZLHad/OpenVideoHarness/pull/25): [`tools/readcheck.py`](../../../tools/readcheck.py) reads a HyperFrames composition without a browser (`bin/vh readcheck index.html`), resolving each clip's span the way HyperFrames does, or taking it from the project's own `hyperframes timeline --json`; `--export` writes that timetable to `texts.json` for hand editing, and `--budget <seconds>` asks how much text fits in a span before it is written. Whatever it cannot time (a reference that does not resolve, text a script draws inside a full-length clip) is listed as not checked and does not count as a pass.
 > - **The intro film**: its text is drawn by script in a Three.js scene and `index.html` has no text clips, so `bin/vh readcheck showcase/04-intro-film/index.html` only answers "NOT CHECKED — no text found"; the 63 windows are still the ones reconstructed from the JS formulas, and the first limit below stands.
 > - **Untouched**: `showcase/04-intro-film` is unchanged on main.
+> - **The rule changed (2026-10-04)**: max(2.5 s, CJK ÷ 4.5 + other ÷ 15 + 1.5 s) below is no longer the floor. The floor is now one brisk read, max(1.5 s, CJK ÷ 7 + other ÷ 20 + 0.8 s), which is #53's short-label rule, the comfortable time follows the BRIEF's `Pace` (relaxed / normal / brisk), and `readcheck` FAILs under the floor and only WARNs under the target; see [`playbook/03-motion-design.md`](../../../playbook/03-motion-design.md) §2. The numbers and figures below use the old rule.
 
 ## Question
 
diff --git a/playbook/01-pipeline.md b/playbook/01-pipeline.md
index f3dabd2..0bdab55 100644
--- a/playbook/01-pipeline.md
+++ b/playbook/01-pipeline.md
@@ -13,7 +13,7 @@
 | 4 音频先行 | `audio/*`、`timeline.json`（词级时间）、`beats.json` | 见 `04-audio.md` | 用实测时长回写分镜 |
 | 5 搭引擎 | 渲染脚本、公共库（hash、ease、keyframe、camera、pulse），先做一个样板场景 | `engines/README.md` | 乱序跳到同一帧，结果一致 |
 | 6 写场景 | 每个场景一个文件；长片按 chapter 分给多个 subagent | Claude Code subagents | 每个场景都过 lint、sheet、strip、crop |
-| 7 Review | `out/check/*.jpg` 和 `NOTES.md` 里的评分记录 | 全新上下文的 reviewer subagent，对照 `TASTE_CHECKLIST.md` | 20 条全 PASS；整片 draft 过 1 轮打分层，修最差的 3 处（`studio` 至少 3 轮，八个维度都 ≥ 8） |
+| 7 Review | `out/check/*.jpg` 和 `NOTES.md` 里的评分记录 | 全新上下文的 reviewer subagent，对照 `TASTE_CHECKLIST.md` | 20 条全 PASS；整片 draft 过 1 轮打分层，修最差的 3 处（`studio` 至少 3 轮、最多 10 轮，八个维度都 ≥ 8）；小修只做局部复查 |
 | 8 渲染 | 先出 draft，给人审阅后再出 final | 并行 worker；ffmpeg 合成，加 `loudnorm` | `ffprobe`、`blackdetect`、`freezedetect` 都通过；**人工关卡 ③**（draft） |
 | 9 交付 | mp4、源码、渲染命令、素材台账、`LESSONS.md` | — | 用户完整看一遍、听一遍 |
 
@@ -191,7 +191,7 @@ animatic 是整片长度的灰盒预演，属于阶段 3，放进关卡 ② 的
 
 - **只认用户本人的原话。** 必须是用户在对话里明确说的；协调者或别的 agent 转述的不算。subagent 收到"直接做完"的转述时，由持有原话的主会话去记录授权。
 - **原话逐字记进 `REVIEW.md`**，写在每道被跳过的关卡下，附日期和范围（跳哪几关）。格式见 `templates/REVIEW.md` 文末。
-- **独立 reviewer 代审。** 被跳过的关卡由全新上下文的 reviewer 代替人来审：`02-verification.md` 第 5 层的人设，TASTE_CHECKLIST 的 20 条加打分层。每轮的问题和修法记进 `NOTES.md`。
+- **独立 reviewer 代审。** 被跳过的关卡由全新上下文的 reviewer 代替人来审：`02-verification.md` 第 5 层的人设，TASTE_CHECKLIST 的 20 条加打分层。每轮的问题和修法记进 `NOTES.md`。上限照旧：整片评审最多 10 轮，同一类问题最多改 5 次；到了上限还没解决的口味问题，随成片交给人。底线条目（TASTE_CHECKLIST 标【底线】的）到了上限还 FAIL，交付物第一行写明"有底线 FAIL，不是可发版本"，不出 final，等人定。
 - **交付时说清楚**哪些关卡是代审的。用户看完成片的意见照常记进 `REVIEW.md`，之后回到正常流程。
 
 本仓库的介绍片是一个例子（项目在 `projects/` 下，不入库，这里只描述）：关卡 ① 之后，用户在对话里说"你自己做好 早上9点我希望能看到成片"。关卡 ②③ 由协调者和两轮独立 reviewer 代审，第一轮的结论是"修完才能发"，第二轮是"小修即可发"。REVIEW.md 里记着原话、日期和代审记录。用户看完成片后的意见按正常流程处理，见文末"多轮迭代是常态"的最后一条。
diff --git a/playbook/02-verification.md b/playbook/02-verification.md
index f770f46..0d0a6aa 100644
--- a/playbook/02-verification.md
+++ b/playbook/02-verification.md
@@ -7,7 +7,7 @@
 做到第几层，按努力程度定（CLAUDE.md"努力程度"）：
 - `quick`：第 1、2 层，加上整片一张联系表、一张按目标屏缩的联系表和前 2 s 的逐帧 strip（命令见下文"手机测试"），出片前跑 `bin/vh check`；
 - `standard`：七层都做，第 5 层的独立评审做 1 轮；
-- `studio`：七层都做，第 5 层至少 3 轮，外加下文的循环接缝、无损确定性和音频 QA（手机测试每一档都做）。
+- `studio`：七层都做，第 5 层至少 3 轮、最多 10 轮，外加下文的循环接缝、无损确定性和音频 QA（手机测试每一档都做）。
 
 1. **能不能跑**：lint、编译、dry-run。Manim 的报错按 ScopeRefine 的顺序修：先改出错行前后 ±1 行，不行就改整个代码块，再不行就重写整个场景。
 2. **不看图的结构检查**（确定性检验：从中间抽几帧单独渲染，和整片里的同一帧比对，要逐像素相同，或者 PSNR ≥ 45 dB；比的是无损 PNG 帧，不是编码后的 mp4，原因见下文"确定性"；`ffmpeg -i a.png -i b.png -lavfi psnr -f null -`）：
@@ -25,8 +25,11 @@
 4. **VLM 批评要给离散选项**：让模型从锚点网格里选位置（Code2Video 的做法），或者从几个渲染出来的变体里挑一个（Paper2Video 的做法）。不要让它输出"往左移 12px"这种数值微调。每轮最多列 3 个问题，每个问题都附一条可以直接执行的修改。
 5. **reviewer subagent**：开一个全新上下文，只给它联系表、`TASTE_CHECKLIST.md` 和 `STORYBOARD.md`，让它逐条打分；不合格的退回给写代码的 agent。
    - **人设**：严苛的动效导演，不是为作品自豪的作者。提示词的大意是："这支片子不是你做的。你是一位挑剔的动效导演，任务是找出它为什么还不能发。"作者自己看久了会习以为常，换一个没有感情投入的人才看得出。
-   - **输入**：除了上面三样，整片 draft 还要给目标屏联系表、关键动作和转场的 strip、cue check 结果。不给作者的 NOTES 自评，免得 reviewer 被作者的解释带偏；只另外给 BRIEF 的立意一行和 `DECISIONS.md` 里口味覆盖的几行，让它判断立意落没落到画面上、每个覆盖站不站得住。
-   - **输出**：20 条 PASS/FAIL，加上 `TASTE_CHECKLIST.md` 文末打分层的八个维度（1–10 分，含立意），再列出最差的 3 个问题，每个都写时间点和改法。有 FAIL，或任何维度低于 8，就退回；至少跑 3 轮，每轮只重渲受影响的时间段。
+   - **输入**：除了上面三样，整片 draft 还要给目标屏联系表、关键动作和转场的 strip、cue check 结果。不给作者的 NOTES 自评，免得 reviewer 被作者的解释带偏；只另外给 BRIEF 的立意一行和 `DECISIONS.md` 里口味覆盖的几行，让它判断立意落没落到画面上、每个覆盖站不站得住。NOTES 里已经交给人的"已知局限"也给它，让它别再把这几条排进最差的 3 个。BRIEF 的 `Pace` 一行也给它：#5 只在字停不够快读一遍时判 FAIL，比 Pace 的目标短一点只算口味意见，可以排进最差的 3 个，但不是 FAIL。
+   - **输出**：20 条 PASS/FAIL，加上 `TASTE_CHECKLIST.md` 文末打分层的八个维度（1–10 分，含立意），再列出最差的 3 个问题，每个都写时间点和改法。有 FAIL，或任何维度低于 8，就退回；`studio` 至少跑 3 轮，每轮只重渲受影响的时间段。
+   - **上限**：整片评审最多 10 轮，到了就停，过线交付，没过线带着分数进关卡 ③；同一类问题（同一条清单条目落在同一个镜头或段落上）最多改 5 次，第 5 次还没解决就写进 NOTES 的"已知局限"，交给人。每轮在 NOTES 的"评审记录"记一行，问题计数表跟着加（格式见 `templates/NOTES.md`）。
+   - **小修只做局部复查**：一条标签的时间或字号、在安全框里挪一挪、一个音效的音量、一个镜头的排版，这类改动只查改过的那一段：这一段的帧和 strip，覆盖它的自动检查（`bin/vh readcheck`、`bin/vh qa`、`bin/vh sheet`、下文"静默失败"的像素扫描、`hyperframes snapshot`），再加作者自己看一遍。不为它重开整片评审。新开一轮只为结构性的改动（几个小节一起重排时间、重写一个场景、换一个结尾）或最后一遍。`studio` 的前 3 轮不受这条限制。
+   - **后一轮推翻前一轮**：每轮都是新 reviewer，口味上难免互相打架：这一轮嫌停留太长，下一轮嫌太短。口味条目（没标【底线】的）上后一轮和前一轮说法相反时，作者可以保留前一轮的决定，在 `DECISIONS.md` 记一行为什么，不算没修；这一行跟口味覆盖一起给下一轮 reviewer。底线条目照常要 PASS。
 6. **整片理解**（可选）：Gemini 能直接读视频，但默认按每秒 1 帧采样，只适合检查叙事和粗略的音画对齐，快速动作里的问题它看不出来。
 7. **人**：最终对听感和品味把关。
 
diff --git a/playbook/03-motion-design.md b/playbook/03-motion-design.md
index 86b7f89..4185e69 100644
--- a/playbook/03-motion-design.md
+++ b/playbook/03-motion-design.md
@@ -79,14 +79,26 @@
 - 逐词 stagger 表达情绪：40ms 急促（适合短视频 hook），80ms 像对话，150ms 像纪录片，250ms 以上有仪式感。每个词至少可见 0.4s，整句出完再停 0.4–0.6s。
 - 屏幕文字：
   - 同屏密度：英文不超过 8 个词；中文字幕每行不超过 16 字（Netflix 中文字幕规范，针对横屏）。竖屏的安全框只有 810px 宽，72px 字号每行最多 11 字，90px 最多 9 字。
-  - 停多久分三种文字算。规则管的不是一件事：画面文字和短标签是最少在屏时间，字幕是读速上限，同一支片子里可以同时成立。时间都从字完整显示、动画停下那一刻算起（decode 字从定住算，见第 4 节）。
-    - **画面文字**（标题、结论、数字卡，没有人念、观众要记住的）：至少停 max(2.5 s, 汉字数 ÷ 4.5 + 其他非空白字符数 ÷ 15 + 1.5 s)。公式来自 lemo-opuscar 的 `core/render/readcheck.mjs` 和 `DIRECTOR.md` §7（MIT），2.5 s 的下限是本仓库原有的规则。16 个汉字的一行要停约 5.1 s，一个 4 字标签停 2.5 s。
-    - **短标签**（镜头在走、只起提示作用的几个词：节点名、站名、关卡字幕）：读一遍就够，max(1.5 s, 汉字数 ÷ 7 + 其他非空白字符数 ÷ 20 + 0.8 s)，中英双语时取慢的那个；HyperFrames 合成里标 `data-read="label"`，`readcheck` 就按这条查。这条是本仓库的规则，来自介绍片 v5 的返工（见下面的"补读时别拖慢整片"）。拿不准算标签还是画面文字时，问一句：观众离开这一镜时要不要记住它？要记住就按画面文字。
-    - **字幕条**（跟着配音走）：中文不超过 9 字/秒，半角字符算半个；英文不超过 20 字符/秒，空格和标点都算（两个数都是 Netflix 对成人节目的规定）。每条至少 1.8 s（lemo 的 `DIRECTOR.md` §7）。字幕的时长本来由配音决定，这条抓的是一句里塞了太多字；一句念得短于 1.8 s 时，`bin/vh captions` 把它的结束时间往后延进后面的空隙（见 `playbook/04-audio.md`）。
+  - 停多久：不写死秒数。读时分两层：底线只保证读一遍，舒服的时长跟着片子的节奏走。画面文字和短标签管的是最少在屏时间，字幕管的是读速上限，同一支片子里可以同时成立。时间都从字完整显示、动画停下那一刻算起（decode 字从定住算，见第 4 节）。
+    - **底线：够快读一遍**（TASTE_CHECKLIST #5 的【底线】）：要观众读的画面文字至少停 max(1.5 s, 汉字数 ÷ 7 + 其他非空白字符数 ÷ 20 + 0.8 s)，中英双语取慢的那个。这就是介绍片 v5 逐帧量过的短标签规则（#53）；1.5 s 防一闪而过。20 个非空白字符约是 4 个英文词，20 字符/秒约合一分钟 240 词，是成人默读非虚构文字的平均速度（Brysbaert 2019 的元分析：238 词/分），也就是说只算读速的话，约一半人读不完一遍，所以加时不能省；7 字/秒是照同样的松紧给中文的假设，没有直接出处（跨语言的朗读常模给中文约 4.3 字/秒）。0.8 s 是眼睛找到字、落上去的时间。16 个汉字的一行约 3.1 s，4 字的标签 1.5 s。底线不随 Pace 变。
+    - **目标：跟着 Pace 走**（默认口味，不是底线）：BRIEF 的 `Pace` 一行定全片的字读得多从容，默认 `normal`。目标从不低于底线。
+
+      | Pace | 汉字/秒 | 其他字符/秒 | 另加 | 16 字一行 | 4 字标签 | 适合 |
+      |---|---|---|---|---|---|---|
+      | `relaxed` | 4.5 | 15 | 1.0 s | 4.6 s | 1.9 s | 讲解、论文、书信体、沉思：观众要边读边想 |
+      | `normal` | 6 | 18 | 0.8 s | 3.5 s | 1.5 s | 大多数片子 |
+      | `brisk` | 7 | 20 | 0.8 s | 3.1 s | 1.5 s | 快剪、梗、卡点 MV；就是底线 |
+
+      - 数从哪来：`relaxed` 沿用旧规则的读速（lemo-opuscar `core/render/readcheck.mjs` 和 `DIRECTOR.md` §7 的 4.5 字/秒、15 字符/秒，MIT），找字时间从 1.5 s 降到 1.0 s，去掉了 2.5 s 的下限；`brisk` 就是底线，底线本来就是"快读一遍"，比它更快的目标永远够不着（起初提的 8 字/秒 + 0.3 s 在每个长度上都低于底线，所以并进了底线）；`normal` 的读速取两者之间，其他字符按同样的比例取 18，加时和底线一样是 0.8 s，这样三档在任何字数上都不交叉。三档都没有拿观众测过，是起点，不是定论；底线拿介绍片 v5 量过。
+      - 一段可以和全片不一样：从容的片子里插一段快剪，或者反过来。HyperFrames 合成里在片段或场景上标 `data-pace="brisk"`（最近的标记生效），`texts.json` 里写 `"pace": "brisk"`。
+      - 可以按 `brisk` 走的字：观众已经知道它说什么、扫一眼确认就够的，例如字幕说的正是画面刚演过的、术语卡第二次出现、片尾回扣开头的那句；还有镜头在走、只起提示作用的短标签（节点名、站名、关卡字幕），标 `data-read="label"`，不论 Pace 都按 `brisk`。拿不准算标签还是画面文字时，问一句：观众离开这一镜时要不要记住它？要记住就按画面文字。
+      - 卡在音乐上的字：进出落在拍子或小节线上，停留按小节取，不为凑够目标的秒数补一截。离目标最近的那条小节线还不到底线，就往后多给一小节；过了底线、只是不到目标，就留着。
+      - WARN 是提醒，不是返工单：`readcheck` 报 WARN 时看一眼是不是有意为之（卡在小节线上、重复的字、这一段本来就快），是就留着，不用记 `DECISIONS.md`。一大片都是 WARN，多半是 Pace 定错了，或者字太多：删字，或者改 BRIEF 的 Pace，不要逐条拉长。改 Pace 要在 `DECISIONS.md` 记一行；人点名要定 `rhythm`（剪辑节奏）时，改 Pace 先问人。
+    - **字幕条**（跟着配音走）：中文不超过 9 字/秒，半角字符算半个；英文不超过 20 字符/秒，空格和标点都算（两个数都是 Netflix 对成人节目的规定）。每条至少 1.8 s（lemo 的 `DIRECTOR.md` §7）。字幕的时长本来由配音决定，所以不跟 Pace；这条抓的是一句里塞了太多字。一句念得短于 1.8 s 时，`bin/vh captions` 把它的结束时间往后延进后面的空隙（见 `playbook/04-audio.md`）。
     - **跟着旁白念的字幕，标 `data-read="subtitle"`**：画面上烧的字就是旁白的字，观众边听边核对，该按字幕的读速算，不该按画面文字算。HyperFrames 合成里给这样的片段标 `data-read="subtitle"`（标在片段上，或标在包着它的片段、场景上），`bin/vh readcheck index.html` 就用字幕的规则查它：输出里带 `sub` 标记，和别的文字一起算进总数。没标的仍按画面文字查，旁白没念的标题、标注、数字卡不要标；`data-read="onscreen"` 可以在被标的场景里把某一条改回去。导出的 `texts.json` 里是 `"read": "subtitle"`，手写的列表也认。
-    - 为什么不一样【综合】：字幕和声音同时到，观众是在核对刚听到的话，可以读得快；画面文字没有声音帮忙，观众要先在画面里找到它，再从头读一遍，所以读速放慢（中文正好是字幕的一半，4.5 对 9 字/秒），另加 1.5 s 找字的时间。短的画面文字靠 2.5 s 兜底，长句靠公式兜底。
-    - 检查：`python3 tools/readcheck.py <texts.json>` 查画面文字，加 `--mode subtitle` 查字幕。输入是 `[{text, start, end}]`，`bin/vh captions` 写的 `captions.json` 可以直接用；它只看时间，字有没有被裁出画面要看联系表。
-    - **补读时别拖慢整片**【实测】：介绍片 v5 为了让每条标签都过上面的公式，一轮轮拉长停留，片长 87.5 → 150.5 s，人看完说"文字显示后的停顿太长了……但也不是那种一闪而过的"。最后的做法是给短标签读一遍的时间（上面的短标签规则），逐帧量过只补真正一闪而过的那几条，片长 103 s，人认可了节奏。补出来的时间里音乐不能停：让配乐"屏息"（鼓撤掉）来配合停留，26 处下来整片像一直在卡顿，加长的小节应当照常往下走（`showcase/04-intro-film` 的 `js/tmap.js`、`tools/retime.py`）。
+    - 为什么字幕和画面文字不一样【综合】：字幕和声音同时到，观众是在核对刚听到的话，读速上限可以高（中文 9 字/秒）；画面文字没有声音帮忙，观众要先在画面里找到它再读，所以底线用快读一遍的速度（7 字/秒），另加 0.8 s 找字。
+    - 检查：`bin/vh readcheck <texts.json | 项目 | index.html>`。Pace 从项目的 BRIEF 读，`--pace` 可以临时换一档；低于底线报 FAIL（退出 1），只低于目标报 WARN（退出 0）；`--mode subtitle` 查字幕。输入是 `[{text, start, end}]`，`bin/vh captions` 写的 `captions.json` 可以直接用；它只看时间，字有没有被裁出画面要看联系表。还没写字时，`bin/vh readcheck --budget <秒>` 算一段时间里放得下多少字。
+    - **为什么不写死秒数**【实测】：介绍片 v5 为了让每条标签都过旧规则 max(2.5 s, 汉字数 ÷ 4.5 + 其他字符数 ÷ 15 + 1.5 s)，一轮轮拉长停留，片长 87.5 → 150.5 s，人看完说"文字显示后的停顿太长了……但也不是那种一闪而过的"。改成只给短标签读一遍的时间、逐帧量过只补真正一闪而过的那几条以后，片长 103 s，人认可了节奏。下一支 `studio` 片子做完，维护者又说"项目中关于字的节奏也不要写死间隔时间，有的时候太慢"（2026-10-04），于是改成现在的两层：底线只管读一遍（就是 v5 用的那条短标签规则），从容多少交给 Pace 和音乐。补出来的时间里音乐不能停：让配乐"屏息"（鼓撤掉）来配合停留，26 处下来整片像一直在卡顿，加长的小节应当照常往下走（`showcase/04-intro-film` 的 `js/tmap.js`、`tools/retime.py`）。
 - 数据图表转场约 1s，分阶段进行（Heer & Robertson 2007）。
 - 变形容器里的字（胶囊、卡片在形状之间变形）：容器开始变形约 0.08s 后字再入场，下一次变形开始前约 0.1s 字先退场。字不跟着容器一起拉伸，也不在形状还没稳住时出现。
 
diff --git a/recipes/README.md b/recipes/README.md
index 59d281b..6f4e663 100644
--- a/recipes/README.md
+++ b/recipes/README.md
@@ -27,7 +27,7 @@
 
 改写外部配方时已经和本仓库的规则对齐过，下面几处和原文不同，每张配方的"来源"一节写了具体改了什么：
 
-- **画面文字停到读完**：没人念的字从完整显示起至少停 max(2.5 s, 读时公式)（TASTE_CHECKLIST #5，`bin/vh readcheck`）。shotcraft 的字卡整张只有 1.8 s，所以改写后的字卡、黑场字卡、字标开场都变长了。
+- **画面文字停到读完**：没人念的字从完整显示起，底线是够快读一遍（max(1.5 s, 汉字数 ÷ 7 + 其他字符数 ÷ 20 + 0.8 s)），舒服的时长按 BRIEF 的 Pace（TASTE_CHECKLIST #5，`bin/vh readcheck`）。配方里的例子按 normal 算；shotcraft 的字卡整张只有 1.8 s，停留那一截不够快读一遍，所以改写后的字卡、黑场字卡、字标开场都长一些。
 - **要读的字不小于 44 px**（1080p 的辅助文字下限）：原文里 25–26 px 的副标、标语都提上来了。
 - **片中没有数字静音**：原文让黑场和死寂段的声音同帧全静，改写后保留一层很低的底（CLAUDE.md 底线）。
 - **强调词不用斜体**（`playbook/03-motion-design.md` §4），改用字重或强调色。
@@ -69,7 +69,7 @@
 
 | 配方 | 一句话 | 能量 | 时长 | 状态 |
 |---|---|---|---|---|
-| [black-card](seam/black-card.md) | 前镜淡进暗场，一句短话逐词压印上屏，停到读完，再淡入后镜：换章节和喘口气一起做 | 1–2 | 4.2–5.8 s | tuned |
+| [black-card](seam/black-card.md) | 前镜淡进暗场，一句短话逐词压印上屏，停到读完，再淡入后镜：换章节和喘口气一起做 | 1–2 | 3.2–5.4 s | tuned |
 | [cut-the-curve](seam/cut-the-curve.md) | 前景加速着朝一个方向走出一小段，切点落在运动正快的时候，后景从反方向以同样的速度接着走、减速落定 | 2–4 | 0.53–0.73 s | tuned |
 | [dark-tunnel](seam/dark-tunnel.md) | 前景顺着运动方向推出画面，穿过几帧有尘点的暗场，后景从景深里迎面放大、收焦 | 4–5 | 0.73–1.1 s | tuned |
 | [flash-cut](seam/flash-cut.md) | 前镜推近到切点，硬切处骑一层 10 帧的暖白光，盖住换页 | 2–4 | 0.33 s | upstream-tested |
@@ -92,8 +92,8 @@
 
 | 配方 | 一句话 | 能量 | 时长 | 状态 |
 |---|---|---|---|---|
-| [brand-imprint-open](type/brand-imprint-open.md) | 一个小记号先画出来，字标逐字压印，副标打出，整组停到读完再上浮离场，交给产品画面 | 1–2 | 3.7–5.8 s | upstream-tested |
-| [breath-title-card](type/breath-title-card.md) | 一句话逐词压印上屏，只有一个强调词，短横线收住，停到读完：两段高能镜头之间的喘息和路标 | 1–2 | 3.3–5 s | upstream-tested |
+| [brand-imprint-open](type/brand-imprint-open.md) | 一个小记号先画出来，字标逐字压印，副标打出，整组停到读完再上浮离场，交给产品画面 | 1–2 | 3–5 s | upstream-tested |
+| [breath-title-card](type/breath-title-card.md) | 一句话逐词压印上屏，只有一个强调词，短横线收住，停到读完：两段高能镜头之间的喘息和路标 | 1–2 | 3.2–5.5 s | upstream-tested |
 | [decode-type](type/decode-type.md) | 字像被程序一点点解出来：乱码按 2 帧一换，每个字在 0.3 s 内依次锁定，锁定之后才开始算读的时间 | 2–4 | 0.2–1 s | tuned |
 
 **开场 `open/`、界面 `ui/`、交互 `interaction/`、运镜 `camera/`、收尾 `outro/`**
diff --git a/recipes/rhythm/drop-blackout-slam.md b/recipes/rhythm/drop-blackout-slam.md
index 2064754..52e2c82 100644
--- a/recipes/rhythm/drop-blackout-slam.md
+++ b/recipes/rhythm/drop-blackout-slam.md
@@ -48,7 +48,7 @@ derived_from:
 | 三件事同帧 | 砸入、震屏、亮环在同一帧开始，同一帧落在音乐的最强一击上 | 错开一两帧，冲击就散了 | ★ |
 | 震屏 | 10 px，τ ≈ 2.5 帧，约 12 帧收干，之后强制为 0 | 衰减慢了就成了持续的抖；收干后必须真静止 | |
 | 次数 | 全片 1 次；算一处整画面冲击（全片最多 3 处） | 第二次出现，第一次就白打了 | ★ |
-| 收尾 | 砸入后 ≥ 50 帧静止；砸出来的字要读，按读时规则不少于 2.5 s | 重拳之后 hold 加倍 | ★ |
+| 收尾 | 砸入后 ≥ 50 帧静止；砸出来的字要读，按读时规则（BRIEF 的 Pace）停够 | 重拳之后 hold 加倍 | ★ |
 
 ## 声音
 
diff --git a/recipes/rhythm/paparazzi-flash.md b/recipes/rhythm/paparazzi-flash.md
index 27e8c9d..084dfcf 100644
--- a/recipes/rhythm/paparazzi-flash.md
+++ b/recipes/rhythm/paparazzi-flash.md
@@ -51,7 +51,7 @@ derived_from:
 | 快门余韵 | 切入的画面 1.03 → 1、上移 16 px → 0，6 帧 | 去掉余韵，三闪读作翻页 | |
 | 三个裁切 | 同一个素材：1.0 全景 / 2.3 卡片 / 4.0 数字，一层比一层近 | 顺序乱了（特写 → 全景 → 特写）读作剪错了；换了素材就不是"被拍到" | ★ |
 | 闪之前 | 活的素材，慢推 | 闪之前是死图，读不出"定格" | |
-| 定格 | 第三闪后停 60 帧 | 三闪是重击，hold 要给到平常的两倍以上；数字要读，按读时规则不少于 2.5 s 时再加长 | ★ |
+| 定格 | 第三闪后停 60 帧 | 三闪是重击，hold 要给到平常的两倍以上；数字要读，读时规则（BRIEF 的 Pace）要得更长时再加长 | ★ |
 | 次数 | 全片 1 次；和 [accelerando-cuts](accelerando-cuts.md) 一样，都算一处整画面冲击 | 第二次出现，第一次就白打了 | ★ |
 
 ## 声音
diff --git a/recipes/seam/black-card.md b/recipes/seam/black-card.md
index a139d6c..38672fa 100644
--- a/recipes/seam/black-card.md
+++ b/recipes/seam/black-card.md
@@ -6,7 +6,7 @@ family: seam
 role: [seam, breath]
 intent: [chapter, breath]
 energy: [1, 2]
-duration_f: [125, 175]
+duration_f: [96, 161]
 jump: [drop, level]
 types: [promo, short, paper, data, math]
 engines: [canvas, hyperframes]
@@ -14,7 +14,7 @@ aspect: [landscape, portrait, square]
 needs: [text]
 sound: recommended
 pitfalls: [no-hold, dead-frame, copy-drift, overuse]
-qa: {read: 45, settle: 90, last: 125}
+qa: {read: 45, settle: 60, last: 96}
 status: tuned
 max_per_film: 2
 pairs_with: [focus-handoff, breath-title-card]
@@ -38,16 +38,16 @@ derived_from:
 | 前镜淡出 | 0–8（6–10） | 淡到暗场，`bezier(0.5,0,0.4,1)` |
 | 暗场 | 8–20 | 静，只有底垫的声音在继续 |
 | 压印 | 18–38 | 字卡淡入（18–26）；第 i 个词在 20 + 3i 帧开始，9 帧压到位；强调色短线 32–44 帧长出 |
-| 停留 | 38–113 | 整句静止，时长按读时规则算：这句是 75 帧 |
-| 退场 | 113–121 | 整张字卡 8 帧淡出 |
-| 后镜淡入 | 121–129（6–10） | 字卡完全退掉以后再进后镜 |
+| 停留 | 38–84 | 整句静止，时长按读时规则算：这句 13 个字符，Pace 为 normal 时是 46 帧 |
+| 退场 | 84–92 | 整张字卡 8 帧淡出 |
+| 后镜淡入 | 92–100（6–10） | 字卡完全退掉以后再进后镜 |
 
 ## 参数
 
 | 参数 | 值 | 调节手感 | ★ |
 |---|---|---|---|
-| 停留 | 从最后一个词落定算起，max(2.5 s, 汉字数 ÷ 4.5 + 其他字符数 ÷ 15 + 1.5 s)；旁白念这句时跟旁白走 | 这是本仓库的读时规则（TASTE_CHECKLIST #5，`bin/vh readcheck` 可算）。shotcraft 原 demo 只停 15 帧，过不了这条线 | ★ |
-| 文案长度 | ≤ 5 个英文词或 ≤ 10 个汉字 | 越长停得越久，字卡就成了一页 PPT；7 个英文词要停 4 s | ★ |
+| 停留 | 从最后一个词落定算起，底线是够快读一遍（max(1.5 s, 汉字数 ÷ 7 + 其他字符数 ÷ 20 + 0.8 s)），舒服的时长按 BRIEF 的 Pace（normal：汉字数 ÷ 6 + 其他字符数 ÷ 18 + 0.8 s，不低于底线）；旁白念这句时跟旁白走；当喘息用时可以停得比读时长，落在小节线上 | 这是本仓库的读时规则（TASTE_CHECKLIST #5，`bin/vh readcheck` 可算）。shotcraft 原 demo 只停 15 帧，连快读一遍都不够 | ★ |
+| 文案长度 | ≤ 5 个英文词或 ≤ 10 个汉字 | 越长停得越久，字卡就成了一页 PPT；7 个英文词按 normal 要停约 2.5 s，按 relaxed 要 3 s 多 | ★ |
 | 逐词压印 | 第 i 个词 delay = 20 + 3i 帧，9 帧；缩放 1.3 → 1、透明度 0 → 1、模糊 7 px → 0；`bezier(0.2,0.75,0.3,1)` | 和 `breath-title-card` 同一套压印，只是更快（3 帧一个词）、底换成暗场 | |
 | 字色 | 用风格里较亮的那个颜色（亮底风格就是底色） | 暗底配强调色正文、或者配纯白等宽字，像系统报错弹窗 | ★ |
 | 强调 | 一句只有一个强调词：强调色 + 加粗一档，不用斜体 | 两个强调词等于没有；斜体见 playbook/03 §4 | |
@@ -68,8 +68,9 @@ derived_from:
 ## 实现
 
 ```js
-// black-card：A 在 10–18 帧暗下去，短句逐词压印，停到读完（2.5 s），字卡退场后淡入 B。
-const T0 = 10, WORDS = ["One", "place", "to", "go."], ACCENT = 1, HOLD = 75;
+// black-card：A 在 10–18 帧暗下去，短句逐词压印，停到读完（按 BRIEF 的 Pace），字卡退场后淡入 B。
+// HOLD：13 个字符，normal 是 13 / 18 + 0.8 s ≈ 46 帧（底线 max(1.5 s, 13 / 20 + 0.8 s) = 45 帧，playbook/03 §2）。
+const T0 = 10, WORDS = ["One", "place", "to", "go."], ACCENT = 1, HOLD = 46;
 export function renderAt(t, ctx, tokens, lib) {
   const k = lib.frame(t) - T0, bg = lib.color(tokens, "bg"), fg = lib.color(tokens, "fg");
   const bgLight = lib.luminance(bg) > lib.luminance(fg);
@@ -120,8 +121,8 @@ function page(ctx, tokens, lib, seed) {                                // 灰盒
 ## 验收帧
 
 - `read`（第 45 帧）：整句已经落定：字号够大，强调词只有一个，短线已经长出。
-- `settle`（第 90 帧）：停留中，画面完全静止；配乐的底垫还在（查音频，不是查画面）。
-- `last`（第 125 帧）：字卡已经退完，后镜正在淡入，两者没有叠在一起。
+- `settle`（第 60 帧）：停留中，画面完全静止；配乐的底垫还在（查音频，不是查画面）。
+- `last`（第 96 帧）：字卡已经退完，后镜正在淡入，两者没有叠在一起。
 
 ## 来源
 
diff --git a/recipes/sequences/README.md b/recipes/sequences/README.md
index fa96b57..721e8eb 100644
--- a/recipes/sequences/README.md
+++ b/recipes/sequences/README.md
@@ -43,7 +43,7 @@
 
 | 什么停住 | 至少停多久 | 出处 |
 |---|---|---|
-| 字标、要读的字 | max(1 s, 读时规则)；读时规则是 max(2.5 s, 汉字数 ÷ 4.5 + 其他字符数 ÷ 15 + 1.5 s)，旁白念的字跟旁白走 | shotcraft 判例 R1；本仓库 TASTE_CHECKLIST #5 |
+| 字标、要读的字 | max(1 s, 读时规则)；读时规则的底线是够快读一遍（max(1.5 s, 汉字数 ÷ 7 + 其他字符数 ÷ 20 + 0.8 s)），舒服的时长按 BRIEF 的 Pace，旁白念的字跟旁白走。下面各骨架的预算表里写"读时"的格子按字数现算（`bin/vh readcheck --budget`）：normal 下一个 4 字的字标 45 帧（就是底线的 1.5 s），一句 16 个字约 105 帧 | shotcraft 判例 R1；本仓库 TASTE_CHECKLIST #5 |
 | 一批元素入场之后 | 15 帧（0.5 s）整体静止 | 判例 R2 |
 | 开场主角的动作弧 | 3 s（产品片） | 判例 R3 |
 | 重击之后（切串、连闪、黑场蓄爆） | 平常的两倍：35–60 帧 | shotcraft `beat-cut-moves` |
diff --git a/recipes/sequences/explainer-30s.md b/recipes/sequences/explainer-30s.md
index b3accbc..4e460dd 100644
--- a/recipes/sequences/explainer-30s.md
+++ b/recipes/sequences/explainer-30s.md
@@ -41,10 +41,10 @@ derived_from:
 | 每句旁白之后 | 画面在句子念完后再停 0.4–0.6 s，才切或开始下一个动作（playbook/03 §2） | 8 × 15 |
 | 第 5 段一口气 | 整段 | 90 |
 | 第 7 段兑现 | 最强的一击之后，停平常的两倍 | 35 |
-| 第 8 段落款 | 停到读完：旁白念的字跟旁白走，没人念的字 ≥ 2.5 s | ≥ 75 |
-| 合计 | | 约 320（36%） |
+| 第 8 段落款 | 停到读完：旁白念的字跟旁白走，没人念的字按读时规则 | 读时 |
+| 合计 | | 约 245 + 读时 |
 
-画面上和旁白同一句话的字，按字幕的规则算（跟着配音走，每条 ≥ 1.8 s；HyperFrames 里给这样的片段标 `data-read="subtitle"`，`bin/vh readcheck` 才按这条查）；画面上旁白没念的字，按画面文字的规则算（≥ 2.5 s）。两条都能用 `bin/vh readcheck` 核。
+画面上和旁白同一句话的字，按字幕的规则算（跟着配音走，每条 ≥ 1.8 s；HyperFrames 里给这样的片段标 `data-read="subtitle"`，`bin/vh readcheck` 才按这条查）；画面上旁白没念的字，按画面文字的规则算（底线是够快读一遍（max(1.5 s, 汉字数 ÷ 7 + 其他字符数 ÷ 20 + 0.8 s)），舒服的时长按 BRIEF 的 Pace）。两条都能用 `bin/vh readcheck` 核。
 
 ## 接缝
 
diff --git a/recipes/sequences/launch-15s.md b/recipes/sequences/launch-15s.md
index 2834005..d2c2d46 100644
--- a/recipes/sequences/launch-15s.md
+++ b/recipes/sequences/launch-15s.md
@@ -37,8 +37,8 @@ derived_from:
 | 1 主角 | 落回槽位后锁死，也是甩镜之前的静止 | 20 |
 | 2 功能 | 满板静止（第 236–270 帧） | 34 |
 | 3 屏息 | 整段 | 30 |
-| 4 落款 | 字标和标语完整后停到读完，最后 12 帧淡出 | ≥ 75 |
-| 合计 | | ≥ 159（35%） |
+| 4 落款 | 字标和标语完整后停到读完，最后 12 帧淡出 | 读时 + 12 |
+| 合计 | | 约 96 + 读时 |
 
 主角的配方要 145–160 帧（锁定到落地约 3.3 s 是判例定下的，不能压）。这一段只给了 135 帧，所以把主角开头"找"的那一段从 32 帧压到 17 帧（中间站减到 2 个），动作弧不动，落地后锁 20 帧（配方要 ≥ 15 帧，甩镜要求甩之前 ≥ 20 帧的静止）：17 + 16 + 10 + 54 + 18 + 20 = 135。甩镜在第 143 帧落位，先静止 20 帧再开始发牌的预备拍；发牌段 88 帧，最后一张在第 236 帧落定，之后满板静止，一直延续到屏息结束。
 
@@ -55,7 +55,7 @@ derived_from:
 ## 限额
 
 - 整画面冲击最多 2 处：第 300 帧那一击，最多再加主角弹起时的一记；15 s 里超过 2 处就只剩吵。
-- 不用字卡和黑场字卡：它们按读时规则至少要 3 s，15 s 的片子放不下；屏息就是这支片子的呼吸位。
+- 不用字卡和黑场字卡：连压印带停留，一张就要 3 s 上下，15 s 的片子放不下；屏息就是这支片子的呼吸位。
 - 闪白最多 1 次；甩镜只用 1 次。
 - 竖屏：主角推近后竖着构图（卡落在关键内容框里），合影的 4–5 个元素上下排列，字标放在 y≈0.3H（playbook/03 §5）。
 
diff --git a/recipes/sequences/machine-eye-portrait.md b/recipes/sequences/machine-eye-portrait.md
index ecc524c..0e8db67 100644
--- a/recipes/sequences/machine-eye-portrait.md
+++ b/recipes/sequences/machine-eye-portrait.md
@@ -47,11 +47,11 @@ derived_from: []
 | 什么 | 先划走的 hold | 帧 |
 |---|---|---|
 | 旁白念的原话 | 跟着旁白走，按字幕规则（每条 ≥ 1.8 s） | 约 20 × 90 |
-| 旁白没念的原话 | 画面文字的读时规则：15 个字约 4.8 s，一般 4–6 s | 约 5 × 150 |
+| 旁白没念的原话 | 画面文字的读时规则，这种片子 Pace 写 relaxed：15 个字约 4.3 s，一般 4–6 s | 约 5 × 150 |
 | 段落之间 | 经黑场淡出再淡入，0.8–1.5 s | 9 × 35 |
 | 第 8 段推断之后 | 停平常的两倍 | 60 |
-| 第 10 段落款 | 停到读完 | ≥ 90 |
-| 合计 | | 约 3015（44%） |
+| 第 10 段落款 | 停到读完 | 读时 |
+| 合计 | | 约 2925 + 读时 |
 
 ## 接缝
 
diff --git a/recipes/sequences/mascot-style-tour.md b/recipes/sequences/mascot-style-tour.md
index 2485091..cecc4dc 100644
--- a/recipes/sequences/mascot-style-tour.md
+++ b/recipes/sequences/mascot-style-tour.md
@@ -43,11 +43,11 @@ derived_from: []
 
 | 什么 | 先划走的 hold | 帧 |
 |---|---|---|
-| 第 2 段的字标 | 读时规则 | ≥ 75 |
+| 第 2 段的字标 | 读时规则 | 读时 |
 | 每个世界落定 | 主角正面清楚的那一下，至少 1 s | 10 × 30 |
 | 第 6 段空黑 | 整段 | 12 |
-| 第 7 段定版 | 停到读完，再加落定后的 0.5 s | ≥ 90 |
-| 合计 | | 约 477（35%） |
+| 第 7 段定版 | 停到读完，再加落定后的 0.5 s | 读时 + 15 |
+| 合计 | | 约 327 + 两处读时 |
 
 ## 接缝
 
diff --git a/recipes/sequences/product-film-60s.md b/recipes/sequences/product-film-60s.md
index d22afe7..43cccf8 100644
--- a/recipes/sequences/product-film-60s.md
+++ b/recipes/sequences/product-film-60s.md
@@ -49,16 +49,16 @@ derived_from:
 
 | 镜头 | 先划走的 hold | 帧 |
 |---|---|---|
-| 1 字标 | 字标完整后停到读完 | ≥ 75 |
+| 1 字标 | 字标完整后停到读完 | 读时 |
 | 2 主角 | 落回槽位后锁死 | 15 |
-| 3、7、10 字卡 | 每张停到读完 | 3 × ≥ 75 |
+| 3、7、10 字卡 | 每张停到读完 | 3 × 读时 |
 | 4 发牌 | 满板静止 | 15 |
 | 5、6、8、9 功能 | 每镜最后一个动作落定后 | 4 × 15 |
 | 11 冲刺 | 最后一刀之后 | 35 |
-| 12 收场 | 落款停到读完 | ≥ 75 |
-| 合计 | | ≥ 500（约 28%） |
+| 12 收场 | 落款停到读完 | 读时 |
+| 合计 | | 125 + 五处读时 |
 
-hold 占到四分之一以上是正常的：shotcraft 的判例里，用户的六次节奏反馈全部是"放慢、停留"，没有一次说太慢（判例 R3）。放不下时，先删一个功能镜头，不要压 hold。
+hold 占到四分之一以上是正常的：shotcraft 的判例里，用户的六次节奏反馈全部是"放慢、停留"，没有一次说太慢（判例 R3）。放不下时，先删一个功能镜头，不要压 hold。读时规则只管字最少停多久；发牌后的满板静止、冲刺后的 35 帧这类呼吸位是节奏，不按读时算，也不因为读时规则变松就跟着压短。
 
 ## 接缝
 
diff --git a/recipes/sequences/time-dilation-replay.md b/recipes/sequences/time-dilation-replay.md
index 5511eec..be32eb5 100644
--- a/recipes/sequences/time-dilation-replay.md
+++ b/recipes/sequences/time-dilation-replay.md
@@ -49,12 +49,12 @@ derived_from: []
 
 | 什么 | 先划走的 hold | 帧 |
 |---|---|---|
-| 第 2 段的"x 秒"大字 | 读时规则（≥ 2.5 s） | ≥ 75 |
+| 第 2 段的"x 秒"大字 | 读时规则 | 读时 |
 | 每次换阶段 | 阶段标签跳到下一个，停 1 s 再讲内容 | 6 × 30 |
 | 第 5 段逗号 | 整段 | 90 |
 | 第 6 段结果诞生之后 | 停平常的两倍 | 45 |
-| 第 8 段读数卡 | 每张按读时规则 | 3 × 75 |
-| 合计 | | 约 615（17%） |
+| 第 8 段读数卡 | 每张按读时规则 | 3 × 读时 |
+| 合计 | | 约 315 + 四处读时 |
 
 跑动的计时读数不要求读完，看得出在走就行；倍数和阶段标签换的时候，要停到读得完（TASTE_CHECKLIST #5）。
 
diff --git a/recipes/sequences/workflow-as-story.md b/recipes/sequences/workflow-as-story.md
index c0e22e4..1f44bfb 100644
--- a/recipes/sequences/workflow-as-story.md
+++ b/recipes/sequences/workflow-as-story.md
@@ -42,12 +42,12 @@ derived_from: []
 
 | 什么 | 先划走的 hold | 帧 |
 |---|---|---|
-| 第 2 段每层的名字 | 读时规则；层名同时出，按整组算 | ≥ 75 |
+| 第 2 段每层的名字 | 读时规则；层名同时出，按整组算 | 读时 |
 | 每一站落定 | 0.5 s 整体静止 | 3 × 15 |
 | 第 5 段末的逗号 | 高潮前 0.3–0.75 s | 15 |
 | 第 7 段成品 | 停平常的两倍 | 35 |
-| 第 8 段产品名 | 停到读完 | ≥ 75 |
-| 合计 | | 约 245（27%） |
+| 第 8 段产品名 | 停到读完 | 读时 |
+| 合计 | | 约 95 + 两处读时 |
 
 ## 接缝
 
diff --git a/recipes/type/brand-imprint-open.md b/recipes/type/brand-imprint-open.md
index f8c6ad0..51c45e7 100644
--- a/recipes/type/brand-imprint-open.md
+++ b/recipes/type/brand-imprint-open.md
@@ -6,14 +6,14 @@ family: type
 role: [open]
 intent: [brand-imprint]
 energy: [1, 2]
-duration_f: [110, 175]
+duration_f: [89, 149]
 types: [promo, short, data, paper]
 engines: [canvas, hyperframes]
 aspect: [landscape, portrait, square]
 needs: [logo]
 sound: recommended
 pitfalls: [no-hold, too-fast]
-qa: {read: 46, settle: 90, last: 124}
+qa: {read: 46, settle: 60, last: 95}
 status: upstream-tested
 pairs_with: [spotlight-hero]
 derived_from:
@@ -37,14 +37,14 @@ derived_from:
 | 字标压印 | 10–46 | 第 i 个字在 10 + 3i 帧开始，12 帧压到位：缩放 1.6 → 1（以字的底边为轴），`bezier(0.2,0.7,0.25,1)`；每个字到位时字底闪一道 8 帧的强调色短划 |
 | 记号淡出 | 24–34 | 记号画完就退，不和字标抢 |
 | 副标打字 | 28 起 | 等宽小字逐字出现，块状光标跟着；打完光标闪，停留期结束前停闪 |
-| 停留 | 46–121 | 从字标完整算起，按读时规则停：这里是 75 帧（2.5 s） |
-| 退场 | 121–128 | 7 帧：整组上浮 40 px、缩小 12%、淡出，交给下一镜 |
+| 停留 | 46–91 | 从字标完整算起，按读时规则停：Pace 为 normal 时是 45 帧（副标 11 个字符最慢，算出 1.4 s，不到底线的 1.5 s，取 1.5 s） |
+| 退场 | 91–98 | 7 帧：整组上浮 40 px、缩小 12%、淡出，交给下一镜 |
 
 ## 参数
 
 | 参数 | 值 | 调节手感 | ★ |
 |---|---|---|---|
-| 停留 | 从字标完整算起，取 max(1 s, 字标和副标各自的读时要求) | shotcraft 判例 R1：用户两轮点名"出现后延长停留 1 秒"；本仓库的读时规则更严（TASTE_CHECKLIST #5），短字标也至少 2.5 s | ★ |
+| 停留 | 从字标完整算起，取 max(1 s, 字标和副标各自的读时要求) | shotcraft 判例 R1：用户两轮点名"出现后延长停留 1 秒"；本仓库再按读时规则（TASTE_CHECKLIST #5，BRIEF 的 Pace）取大，副标长时比 1 s 长 | ★ |
 | 停的对象 | 停的是字标落定的那一刻，不是随便一张内容卡 | 判例 R1：曾把 hold 加错给普通字卡，很快回滚 | ★ |
 | 压印 | 起始缩放 1.6，12 帧，字间隔 3 帧；以字的底边为轴 | 从底边压下去才像印上纸；以中心缩放像弹出来 | |
 | 入场三件套 | 透明度 + 缩放 + 虚焦 → 清晰 | 缺了虚焦会显得硬（原卡）；DOM 里不动画 blur，虚焦放在 canvas 层做，或用预模糊副本交叉淡入 | |
@@ -69,7 +69,8 @@ derived_from:
 // brand-imprint-open：记号描出 → 字标逐字压印（字底 glint）→ 副标打字 → 停到读完 → 7 帧上浮离场。
 const MARK = "Frame Lab", KICKER = "VIDEO AS CODE";
 const DONE = 10 + 3 * (MARK.length - 1) + 12;                          // 字标完整：第 46 帧
-const OUT = DONE + Math.round(Math.max(1, 2.5, MARK.length / 15 + 1.5, KICKER.replace(/ /g, "").length / 15 + 1.5) * 30);
+const CPS = 18, PAD = 0.8, FLOOR = 1.5;                                // BRIEF 的 Pace = normal：其他字符 18 个/秒，另加 0.8 s，不低于底线 1.5 s（playbook/03 §2）
+const OUT = DONE + Math.round(Math.max(FLOOR, MARK.replace(/ /g, "").length / CPS + PAD, KICKER.replace(/ /g, "").length / CPS + PAD) * 30);
 export function renderAt(t, ctx, tokens, lib) {
   const f = lib.frame(t), fg = lib.color(tokens, "fg"), ac = lib.color(tokens, "accent");
   ctx.fillStyle = lib.color(tokens, "bg"); ctx.fillRect(0, 0, 1920, 1080);
@@ -111,8 +112,8 @@ export function renderAt(t, ctx, tokens, lib) {
 ## 验收帧
 
 - `read`（第 46 帧）：字标完整，所有字都已落位；glint 只剩最后一个字的尾巴。
-- `settle`（第 90 帧）：停留中，只有光标在闪，其他全部静止。
-- `last`（第 124 帧）：退场中段，整组在上浮、缩小、变淡，方向和下一镜的运动一致。
+- `settle`（第 60 帧）：停留中，只有光标在闪，其他全部静止。
+- `last`（第 95 帧）：退场中段，整组在上浮、缩小、变淡，方向和下一镜的运动一致。
 
 ## 来源
 
diff --git a/recipes/type/breath-title-card.md b/recipes/type/breath-title-card.md
index e67244d..4a76131 100644
--- a/recipes/type/breath-title-card.md
+++ b/recipes/type/breath-title-card.md
@@ -6,14 +6,14 @@ family: type
 role: [breath]
 intent: [breath, promise]
 energy: [1, 2]
-duration_f: [100, 150]
+duration_f: [96, 166]
 types: [promo, short, data, paper]
 engines: [canvas, hyperframes]
 aspect: [landscape, portrait, square]
 needs: [text]
 sound: optional
 pitfalls: [no-hold, copy-drift, overuse]
-qa: {read: 34, settle: 80}
+qa: {read: 34, settle: 60}
 status: upstream-tested
 max_per_film: 4
 pairs_with: [flash-cut, black-card]
@@ -37,14 +37,14 @@ derived_from:
 |---|---|---|
 | 压印 | 4–21 | 第 i 个词（中文是词块）在 4 + 4i 帧开始，9 帧压到位：缩放 1.28 → 1，透明度 0 → 1，`bezier(0.2,0.75,0.3,1)` |
 | 短线 | 16–34 | 强调色短线从 0 长到 220 px，`bezier(0.3,0,0.2,1)` |
-| 停留 | 34–130 | 从短线长完算起，按读时规则停：这一句是 96 帧（3.2 s） |
-| 退场 | 130–138 | 整张卡 8 帧淡出，交给下一镜 |
+| 停留 | 34–96 | 从短线长完算起，按读时规则停：这一句 Pace 为 normal 时是 62 帧（2.1 s） |
+| 退场 | 96–104 | 整张卡 8 帧淡出，交给下一镜 |
 
 ## 参数
 
 | 参数 | 值 | 调节手感 | ★ |
 |---|---|---|---|
-| 停留 | 没人念：max(2.5 s, 汉字数 ÷ 4.5 + 其他字符数 ÷ 15 + 1.5 s)；旁白念这句：跟旁白走，念完再停 0.4–0.6 s | 本仓库的读时规则（TASTE_CHECKLIST #5，`bin/vh readcheck`）。shotcraft 原卡整张只有 50–55 帧（1.8 s），过不了这条线 | ★ |
+| 停留 | 没人念：底线是够快读一遍（max(1.5 s, 汉字数 ÷ 7 + 其他字符数 ÷ 20 + 0.8 s)），舒服的时长按 BRIEF 的 Pace；旁白念这句：跟旁白走，念完再停 0.4–0.6 s；当喘息用时可以停得比读时长，落在小节线上 | 本仓库的读时规则（TASTE_CHECKLIST #5，`bin/vh readcheck`）。shotcraft 原卡整张只有 50–55 帧（1.8 s），压印完剩下的停留连快读一遍都不够 | ★ |
 | 强调词 | 一句恰好一个：强调色 + 加粗一档；选功能名或收益词 | 两个强调词等于没有。原卡用斜体，本仓库不用斜体做强调（playbook/03 §4） | ★ |
 | 压印 | 起始缩放 1.28，9 帧，词间隔 4 帧 | 1.28 是"压上纸"的读感；逐词间隔再大就像打字机 | |
 | 底色 | 片子自己的底色，中心加一块很淡的暖光 | 和产品画面同一个世界，字卡才不像插播的广告 | ★ |
@@ -68,7 +68,9 @@ derived_from:
 ```js
 // breath-title-card：逐词压印 → 短线 → 停到读完（readcheck）→ 淡出。中文按词块，拉丁文按空格分词。
 const WORDS = ["每一帧，", "都是", "代码。"], ACCENT = 2;
-const HOLD = Math.round(Math.max(2.5, 7 / 4.5 + 2 / 15 + 1.5) * 30);  // 7 个汉字、2 个标点 → 96 帧
+const PACE = { relaxed: [4.5, 15, 1.0], normal: [6, 18, 0.8], brisk: [7, 20, 0.8] };  // 汉字/秒、其他字符/秒、另加秒数（playbook/03 §2）
+const [CJK, OTHER, PAD] = PACE.normal;                                // BRIEF 的 Pace
+const HOLD = Math.round(Math.max(1.5, 7 / CJK + 2 / OTHER + PAD) * 30);  // 7 个汉字、2 个标点 → 62 帧（底线 57 帧）
 const DONE = 34, OUT = DONE + HOLD;                                    // 短线长完 = 完整显示的那一刻
 export function renderAt(t, ctx, tokens, lib) {
   const f = lib.frame(t), bg = lib.color(tokens, "bg");
@@ -94,7 +96,7 @@ export function renderAt(t, ctx, tokens, lib) {
 
 ## 已知坑
 
-- **停得不够**：照搬原卡的 1.8 s，读时检查会不通过，观众也读不完。停留按规则算，排分镜时用 `bin/vh readcheck` 核一遍。
+- **停得不够**：照搬原卡的 1.8 s，压印完剩下的停留不够快读一遍，读时检查报 FAIL，观众也读不完。停留按规则算，排分镜时用 `bin/vh readcheck` 核一遍。
 - **文案抽象**：用户逐字改掉过"one board"一类的隐喻，要求写成"团队 + 功能名 + 收益"（shotcraft 判例 C2）。画面锁定以后，对着最终的镜头把字卡文案重写一遍（判例 C1）。
 - **字卡和收尾标语重复**：同一句话全片只出现一次（判例 P4）。
 - **副行数字没滚完就淡出**：排节拍时从字卡淡出的那一帧往回倒推数字滚动的起点。
@@ -103,7 +105,7 @@ export function renderAt(t, ctx, tokens, lib) {
 ## 验收帧
 
 - `read`（第 34 帧）：整句完整，强调词只有一个，短线已经长完；字号在 1080p 下不小于 84 px。
-- `settle`（第 80 帧）：停留中，画面完全静止，没有还在飘的东西。
+- `settle`（第 60 帧）：停留中，画面完全静止，没有还在飘的东西。
 
 ## 来源
 
diff --git a/styles/blueprint/STYLE.md b/styles/blueprint/STYLE.md
index feadd52..5142d71 100644
--- a/styles/blueprint/STYLE.md
+++ b/styles/blueprint/STYLE.md
@@ -97,7 +97,7 @@ Visual style: engineering blueprint on cyanotype paper. The whole film is one sh
 - 缩到 360 px 宽的手机联系表：线宽层级还分得出吗？
 - 量一处：尺寸数字和图形比例一致吗？
 - 审图黄每个镜头最多一处。
-- 标题栏和注释里要读的字：英文 ≥ 28 px、中文 ≥ 46 px，停 ≥ 2.5 s。
+- 标题栏和注释里要读的字：英文 ≥ 28 px、中文 ≥ 46 px，停到读完（读时规则，TASTE_CHECKLIST #5）。
 
 ## 相关资源
 
diff --git a/styles/clockwork-map/STYLE.md b/styles/clockwork-map/STYLE.md
index b5f309e..6e978e0 100644
--- a/styles/clockwork-map/STYLE.md
+++ b/styles/clockwork-map/STYLE.md
@@ -42,7 +42,7 @@
 
 - **擒纵步进**：所有可见齿轮按八分音符一格一格走。90 BPM 下每个八分音符 10 帧：约 2 帧转过一个齿，末端回弹约 9% 再停住（弹簧 w = 80、ζ = 0.6），其余帧静止。啮合的齿轮中心距等于两者节圆半径之和，转角比等于齿数反比、方向相反，齿不能穿插。齿轮只允许这种步进，不许匀速空转。
 - **机械升起**：一个地点的完整动作 36–54 帧：舱口像光圈一样打开 5 帧，露出坑里在转的齿轮 → 本体顶起 18 帧（`cubic-bezier(0.76,0,0.24,1)`）→ 面板绕铰链逐块翻开，每块 12 帧、错开 2 帧 → 锁止，弹簧 stiffness 500 / damping 36（ζ≈0.8，约 1.5% 回弹），配一声咔哒。沉回地下用 `cubic-bezier(0.5,0,0.75,0)`。
-- **一次只动一台**：同一时刻只有一个主机械在升起，其他地点只有齿轮在走。每 2.5–3.5 s 一个新地点或新动作；每个地点至少停留 2.5 s 让铭牌读完。
+- **一次只动一台**：同一时刻只有一个主机械在升起，其他地点只有齿轮在走。每 2.5–3.5 s 一个新地点或新动作；每个地点停到铭牌读完（读时规则，TASTE_CHECKLIST #5）。
 - **镜头**：一镜到底（oner）。沿地点之间的样条飞行，整段用 easeInOutSine，经过地点时减速到 20–30% 但不停；镜头的俯角和高度也是 t 的函数，不做手持抖动。
 - **转场**（只用这 3 种）：
   - 飞越（fly-over）：地点之间不切，镜头沿方位线飞过去；
@@ -94,7 +94,7 @@ Visual style: clockwork map. The film is one continuous low flight over a parchm
 - 取 8 帧 strip：每个可见齿轮都在驱动东西；相邻齿轮转向相反，齿没有穿插；步进落在八分音符上（±1 帧）。
 - 任意时刻只有一台主机械在动。
 - 暂停在任意一帧，镜头都在运动（飞行中）；停下的只能是机械，不能是镜头。
-- 铭牌上的地名：英文 ≥ 30 px、中文 ≥ 46 px（1080p），铭牌倾角 < 35°，停留 ≥ 2.5 s。
+- 铭牌上的地名：英文 ≥ 30 px、中文 ≥ 46 px（1080p），铭牌倾角 < 35°，停到读完。
 - 黄铜高光不能比铭牌上的字亮；远处的地平线压暗后不能出现摩尔纹和闪烁。
 - 用了真实地理的话，边界来自合规底图，并在 NOTES.md 记下来源。
 
diff --git a/styles/crt-terminal/STYLE.md b/styles/crt-terminal/STYLE.md
index f051bb5..7c99d89 100644
--- a/styles/crt-terminal/STYLE.md
+++ b/styles/crt-terminal/STYLE.md
@@ -44,7 +44,7 @@
 - **打字速度**：机器输出 12–25 ms/字，日志按行滚，40 ms/行；命令 40–60 ms/字；人打字 60–180 ms/字，由种子决定快慢，在词与词之间停顿。光标闪烁周期 530 ms（亮 265、灭 265）。
 - **余辉**：字熄灭后亮度按 `e^(−Δt/τ)` 衰减，P3 琥珀 τ ≈ 0.12 s，P39 长余辉绿 τ ≈ 0.4 s；用解析式算，不存状态。
 - **缓动**：开机和推拉用 easeOutExpo `cubic-bezier(0.16,1,0.3,1)`；关机塌缩用 easeInExpo `cubic-bezier(0.7,0,0.84,0)`；文字本身不缓动，一律 steps。
-- **时长**：一行要读的输出打完后至少停 1.5 s（打字的时间不算读的时间）；要读的句子停 ≥ 2.5 s；每 1.5–3 s 一个新事件（新行、新命令、新状态）。开机 12 帧。
+- **时长**：一行要读的输出打完后停到读完再出下一行（打字的时间不算读的时间；读时规则见 TASTE_CHECKLIST #5）；每 1.5–3 s 一个新事件（新行、新命令、新状态）。开机 12 帧。
 - **转场**（只用这 3 种）：
   - 清屏（clear-screen）：整屏从上到下逐行熄灭，每行 2 帧，熄灭的行带余辉；
   - 字号推拉（grid-zoom）：格子变大就是推近，推进一个字符，它里面是更小的文字；
diff --git a/styles/dark-math/STYLE.md b/styles/dark-math/STYLE.md
index 69d18cd..f3deb6f 100644
--- a/styles/dark-math/STYLE.md
+++ b/styles/dark-math/STYLE.md
@@ -93,7 +93,7 @@ Visual style: dark mathematical explainer. Pure black background, no glow, no pa
 - 放大细节时，父对象是否还在画面里？
 - 公式是否超出安全区，或和图形重叠？（打印包围盒）
 - 每个场景是否只讲了一个 insight？
-- 结论文字至少完整可读 2.5 s；放大或转场的中途，有没有不透明底色盖住被放大的部分？
+- 结论文字至少完整可读 2.5 s（风格节拍：结论要留时间想；比读时底线长）；放大或转场的中途，有没有不透明底色盖住被放大的部分？
 - Manim 陷阱：`self.play(..., rate_func=…)` 会覆盖每个子动画自己的缓动；`always_redraw` 会丢 `z_index`（见 `video-types/01`）。
 
 ## 相关资源
diff --git a/styles/editorial-data/STYLE.md b/styles/editorial-data/STYLE.md
index 9f8296f..2a60581 100644
--- a/styles/editorial-data/STYLE.md
+++ b/styles/editorial-data/STYLE.md
@@ -45,7 +45,7 @@
 - **缓动**：注释入场 easeOutCubic `cubic-bezier(0.33,1,0.68,1)`，12–15 帧；图表变化用 easeInOutCubic `cubic-bezier(0.65,0,0.35,1)`；退场 easeInCubic。时间序列的线**线性**画出，因为横轴就是时间。不用 overshoot。
 - **先猜后揭示**（签名）：先画一条灰色虚线的"你以为的"曲线，停 1.5 s；再用强调色线性画出真实曲线，画到哪里，那里的注释才出现。
 - **重新定标**：数据冲出图框时，先停半拍让观众看见"出界"，再分两段变：坐标轴 0.4 s，数值 0.6 s（Heer & Robertson 2007）。注释钉在数据坐标里（数值 + 像素偏移），跟着点一起走。
-- **时长**：每个被注释的状态至少停 2.5 s；每 3–4 s 一个新的状态或注释；计数不超过 1.5 s，最终状态停 ≥ 2 s。
+- **时长**：每个被注释的状态至少停 2.5 s（风格节拍：要看的是图和它的变化，不只是注释那行字；比读时底线长）；每 3–4 s 一个新的状态或注释；计数不超过 1.5 s，最终状态停 ≥ 2 s。
 - **转场**（只用这 3 种）：同一空间里变值（rescale）；编码变形（morph，点变柱、线变面，分阶段）；整版上滚（scroll-up），像读者往下滚文章，进入下一张图。
 - **镜头**：固定。进入细节时最多一次 ≤ 1.15× 的慢推。
 - **文字动画**：逐词（stagger），80 ms/词，每词上移 12 px 并淡入；中文 60 ms/字。
@@ -91,7 +91,7 @@ Visual style: newspaper graphics desk. Warm newsprint page #FAF8F3, ink #1F1D1A.
 - 屏幕上的每个数字都能对上数据文件，抽 3 个手算。
 - 标题是结论句吗？强调色是否只落在标题说的那条系列上？
 - 放大 crop：每条引线的小圆圈是否正好压在数据点上；rescale 之后是否仍然对准。
-- 注释停留 ≥ 2.5 s，中文注释 ≥ 46 px、英文 ≥ 28 px。
+- 注释停留 ≥ 2.5 s（风格节拍，见上面的"时长"），中文注释 ≥ 46 px、英文 ≥ 28 px。
 - 纵轴从 0 开始（条形图必须）；对数轴要在轴标题里写明"对数刻度"。
 
 ## 相关资源
diff --git a/styles/monumental-scifi/STYLE.md b/styles/monumental-scifi/STYLE.md
index b4752c8..4aa08b8 100644
--- a/styles/monumental-scifi/STYLE.md
+++ b/styles/monumental-scifi/STYLE.md
@@ -63,7 +63,7 @@
 
   不用 crossfade，也不用 wipe。
 - **镜头**：以 dolly 为主（推进或横移），速度恒定，可以一镜到底（oner）。允许一次极慢的上摇揭示高度（6 s 内仰 8–15°）。禁止手持。
-- **文字动画**：stagger。英文逐字母淡入，每个字母间隔 60–80 ms，整行不超过 1.2 s；中文逐字，每字 100 ms。整行出完后停 ≥ 2.5 s。
+- **文字动画**：stagger。英文逐字母淡入，每个字母间隔 60–80 ms，整行不超过 1.2 s；中文逐字，每字 100 ms。整行出完后停 ≥ 2.5 s（风格节拍：字少、动作慢，静是这种风格的一部分；比读时底线长）。
 
 ## 声音语法
 
diff --git a/styles/product-keynote/STYLE.md b/styles/product-keynote/STYLE.md
index 31b86f1..ab432b0 100644
--- a/styles/product-keynote/STYLE.md
+++ b/styles/product-keynote/STYLE.md
@@ -50,7 +50,7 @@
 
   全片没有 overshoot。
 - **先物后字**：产品运动结束 → 停 0.3 s → 标题进场（上浮 16 px 并淡入）→ 副标题再晚 6 帧。
-- **时长**：一个画面 2.5–4 s，每 2.5 s 一个新事件；数字画面停 ≥ 2.5 s；揭示前留 0.5 s 的"戏剧逗号"。
+- **时长**：一个画面 2.5–4 s，每 2.5 s 一个新事件；数字画面停到读完（读时规则，TASTE_CHECKLIST #5）；揭示前留 0.5 s 的"戏剧逗号"。
 - **转场**（全片只用这 3 种）：
   - 卡拍硬切，切在 downbeat 上，前后两镜的产品运动方向一致；
   - 形状匹配切：圆角对圆角，边缘对边缘；
diff --git a/styles/swiss-grid-type/STYLE.md b/styles/swiss-grid-type/STYLE.md
index 8a12caf..af5e361 100644
--- a/styles/swiss-grid-type/STYLE.md
+++ b/styles/swiss-grid-type/STYLE.md
@@ -58,7 +58,7 @@
   - 大数字分 4 步"一格一格"爬到位，每步 1/16。
 - **删除**：一条 2 px 的线在 4 帧内划过元素，元素随后在 8 帧内向中线压扁消失。
 - **连锁**：一个元素到位后，周围的元素按距离由近到远重新排版，每个 1/16 动两个。
-- **节奏**：每 2 拍（约 1.07 s）一个新事件；需要读完的一行字停 ≥ 2.5 s。
+- **节奏**：每 2 拍（约 1.07 s）一个新事件；需要读完的一行字停到读完（读时规则，TASTE_CHECKLIST #5），停留取整到拍子上。
 - **转场**（全片只用这 3 种）：
   - 向左擦除（wipe-left）：一块纸白或墨黑沿网格栏推过去；
   - 网格滑移：整个网格带着内容横移一个跨页；
diff --git a/styles/symmetry-pastel/STYLE.md b/styles/symmetry-pastel/STYLE.md
index 3bd1315..466fcc7 100644
--- a/styles/symmetry-pastel/STYLE.md
+++ b/styles/symmetry-pastel/STYLE.md
@@ -54,7 +54,7 @@
   - 物件入画用 `cubic-bezier(0.33,1,0.68,1)`，10 帧。
 
   不用 bounce。角色和道具可以"一拍二"，做出定格动画的感觉。
-- **时长**：一个对称画面至少停 2 s；每 2.5 s 一个新事件，比如道具出现、人物转头、镜头横移到下一格；章节字卡停 2.5 s。
+- **时长**：一个对称画面至少停 2 s；每 2.5 s 一个新事件，比如道具出现、人物转头、镜头横移到下一格；章节字卡停 2.5 s（风格节拍，像翻过一页书；比读时底线长）。
 - **转场**（全片只用这 3 种）：
   - 甩镜（whip pan），左右交替；在模糊最大的那一帧切，下一场从同方向的模糊中停下；
   - 直切到章节字卡，再直切回来；
@@ -114,7 +114,7 @@ Visual style: symmetrical pastel storybook. Every frame is centred on the vertic
 - 左右翻转差分：每个非运动帧的主体区域都对称。
 - 1 fps 联系表：每章只用它那套颜色，章与章之间颜色切换清楚。
 - 甩镜 strip：切点前后运动方向一致、模糊方向一致，落点画面同样居中。
-- 字卡停留 ≥ 2.5 s，标签字号 ≥ 44 px。
+- 字卡停留 ≥ 2.5 s（风格节拍，见上面的"时长"），标签字号 ≥ 44 px。
 - 声音：每个 whoosh 的峰值与甩镜切点同帧（±1 帧）。
 
 ## 相关资源
diff --git a/templates/BRIEF.md b/templates/BRIEF.md
index ceea687..0e9668c 100644
--- a/templates/BRIEF.md
+++ b/templates/BRIEF.md
@@ -7,6 +7,7 @@
 - Director: default  <!-- 谁拍板：default = 按 Effort 的默认；人点名的写成 hook=own, character=own, packaging=own, rest=delegate（own 人选 / review 人过目 / delegate agent 定），stop=E3 加一个检查点。规则见 CLAUDE.md "导演模式"，对话里说的优先 -->
 - Output: {W}x{H}, {fps} fps, exactly {N}s ({frames} frames)
 - Watch on: {watch}  <!-- 主要在哪看，定字号下限和可读性检查缩到多宽（playbook/03 §4）：phone 手机竖屏；feed 横屏片放在手机信息流里，竖着拿、不转屏；desktop 电脑，或手机转成横屏全屏。bin/vh new 按画幅填了默认值，人说了发在哪就照着改 -->
+- Pace: normal  <!-- relaxed | normal | brisk：画面文字读得多从容，定 bin/vh readcheck 的目标（playbook/03 §2）。relaxed 讲解、论文、书信体，观众边读边想；normal 大多数片子；brisk 快剪、梗、卡点 MV。bin/vh new 给 math、paper 写 relaxed，meme 写 brisk，其余 normal。底线（够快读一遍）不随它变；某一段要换挡，在合成里标 data-pace -->
 - Resolution: {res}  <!-- 默认 1080p。4k：照常按 1080p 写合成和字号，出片时渲成 4K（HyperFrames `render --resolution 4k`，竖屏 `portrait-4k`，方形 `square-4k`，4:5 没有 4K 预设；Manim `-qk --fps 30`；Remotion `--scale=2`）；canvas、Three.js 要按像素密度开大，否则会糊（engines/README.md"出 4K"）；手绘引擎暂不支持 4K；draft 用 1080p，4K 成片裁一两帧看锐不锐 -->
 - Review language: zh  <!-- zh | en：审阅页和审阅台的界面语言，按用户第一句话的语言定（bin/vh new --lang）；字幕和项目文档照旧用项目自己的语言 -->
 - Engine: {HyperFrames | Remotion | Manim CE | ClaudeAnimationBase (p5.brush) | other}
@@ -40,7 +41,7 @@
 Entrances easeOutExpo cubic-bezier(0.16,1,0.3,1) / power3.out; exits ease-in at ~75% of entry; entries <=0.8s; total stagger <=0.5s. No bounce/elastic, no idle breathing loops, no crossfades between scenes; transitions grow out of content; 0.3–0.75s stillness before each climax.
 
 ## Text rules
-<= {8} words (or {16} CJK chars per line) on screen; each block visible >= {2.5}s; min sizes {..}px; everything inside safe box {x0–x1, y0–y1}.
+<= {8} words (or {16} CJK chars per line) on screen; every must-read block stays at least one brisk read (max(1.5s, CJK/7 + other/20 + 0.8s): the floor) and by default reaches the Pace target (bin/vh readcheck; no fixed seconds); min sizes {..}px; everything inside safe box {x0–x1, y0–y1}.
 
 ## Determinism
 Every frame is a pure function of t. No Math.random / Date.now / CSS transitions; seed all noise; no state carried between frames.
diff --git a/templates/NOTES.md b/templates/NOTES.md
index 352f5ba..8e7ce91 100644
--- a/templates/NOTES.md
+++ b/templates/NOTES.md
@@ -19,6 +19,20 @@
 - #__ FAIL: … → …
 - others PASS
 
+## 评审记录
+<!-- 打分层（TASTE_CHECKLIST 文末）。每轮整片评审记一行：第几轮、八项分数（立意/钩子/目标屏可读/运动/变化/构图/准确/声画）、改了什么。整片评审最多 10 轮；小修只做局部复查，不开新的一轮，记在改它的那一行里。 -->
+- R1 · draft{n} · {7/5/5/6/6/5/6/7} · 改了：{…}（局部复查：{时间段}）
+
+### 问题计数
+<!-- 同一类问题 = 同一条清单条目落在同一个镜头或段落上。改一次、查一次（局部复查或整片评审）算一次，最多 5 次；到 5 次还没解决就转进"已知局限"，交给人定。 -->
+| 问题（条目 · 镜头或段落） | 已改几次 | 状态 |
+|---|---|---|
+| {#5 读时 · 卫星段} | {2} | {改着 / 已解决 / 已知局限} |
+
+### 已知局限
+<!-- 改满 5 次仍没解决的，附最后一次的证据（帧、strip、检查输出），交付或进关卡 ③ 时交给人定。 -->
+- {问题} — 最后一次：{证据路径或输出} — 交给人：{要人定什么}
+
 ## 素材台账
 | 文件 | 来源 | 许可 |
 |---|---|---|
diff --git a/templates/REVIEW.md b/templates/REVIEW.md
index 5bd2b36..07d44d5 100644
--- a/templates/REVIEW.md
+++ b/templates/REVIEW.md
@@ -26,7 +26,7 @@
 ```text
 - 用户授权跳过（YYYY-MM-DD）。原话："……"（逐字照抄，不转述）
 - 范围：跳过关卡 ②③（或：只跳过关卡 ③）
-- 代审：独立 reviewer 共 N 轮，每轮结论和打分层的分数见 NOTES.md
+- 代审：独立 reviewer 共 N 轮（整片评审最多 10 轮），每轮结论和打分层的分数见 NOTES.md 的"评审记录"；改满 5 次仍没解决的见"已知局限"
 - 成片仍待用户本人观看，看完的意见记在本关卡下
 ```
 
diff --git a/templates/STORYBOARD.md b/templates/STORYBOARD.md
index e57bb9d..e4f507f 100644
--- a/templates/STORYBOARD.md
+++ b/templates/STORYBOARD.md
@@ -34,7 +34,7 @@ Animatic: {out/animatic.mp4 · draft 画质的灰盒 · 真实 / 占位音频；
 - [ ] 每个镜头都有事件（首帧和末帧之间有东西变了）
 - [ ] 每条 read 在下一条开始前有时间落地（有 animatic 时，按它的实际速度逐镜读过一遍）
 - [ ] 每个接缝都有转场，开头和结尾也有
-- [ ] 文字用量符合类型文档的规则；跟着旁白念的字幕，在合成里标 `data-read="subtitle"`（按字幕的读速查，见 playbook/03 §2）
+- [ ] 文字用量符合类型文档的规则；每条要读的字停够快读一遍，舒服的时长按 BRIEF 的 `Pace`；跟着旁白念的字幕，在合成里标 `data-read="subtitle"`，镜头在走时的短标签标 `data-read="label"`，和全片节奏不一样的一段标 `data-pace`（见 playbook/03 §2）
 - [ ] 结尾与开头呼应（同一地点、姿势或母题，但有变化）
 - [ ] 全片只用 2–3 种转场、一个主运动方向
 - [ ] 用了配方的镜头：读过配方全文和它的实现，★ 参数没有降档；全片的 max_per_film、conflicts、整画面冲击 ≤ 3 处都对过（recipes/sequences/README.md）
diff --git a/templates/TASTE_CHECKLIST.md b/templates/TASTE_CHECKLIST.md
index d998ef6..630627c 100644
--- a/templates/TASTE_CHECKLIST.md
+++ b/templates/TASTE_CHECKLIST.md
@@ -35,7 +35,9 @@ ffmpeg -i out.mp4 -vf "blackdetect=d=0.3,freezedetect=d=1.5" -af silencedetect=d
 4. 标签离对象超过一格，或元素之间有遮挡？
 
 **文字**
-5. 【底线】需要观众读完的文字：同屏超过 8 个英文词，或中文每行超过 16 字（竖屏 72px 时 11 字）？停得不够久？从字完整显示、动画停下那一刻算起，没人念、观众要记住的画面文字（标题、结论、数字卡）要停 max(2.5s, 汉字数 ÷ 4.5 + 其他非空白字符数 ÷ 15 + 1.5s)；镜头在走、只起提示作用的短标签（节点名、站名、关卡字幕这类，几个词）读一遍就够：max(1.5s, 汉字数 ÷ 7 + 其他非空白字符数 ÷ 20 + 0.8s)，取中英文里慢的那个；跟着配音走的字幕条每条 ≥ 1.8s，中文不超过 9 字/秒、英文不超过 20 字符/秒。有时间表就用 `tools/readcheck.py` 逐条算，短标签标 `data-read="label"`（三条规则为什么不同，见 `playbook/03-motion-design.md` §2）。为补读时拉长停留，音乐不能跟着停。读的那段时间里，字还在 decode 乱码，或被运动模糊抹花？（真实 UI 截图里的文字、背景纹理文字只要求"看得出是什么"，不要求读完）
+5. 【底线】需要观众读完的文字：同屏超过 8 个英文词，或中文每行超过 16 字（竖屏 72px 时 11 字）？停得不够快读一遍？从字完整显示、动画停下那一刻算起，要读的画面文字至少停 max(1.5s, 汉字数 ÷ 7 + 其他非空白字符数 ÷ 20 + 0.8s)，中英双语取慢的那个（1.5s 防一闪而过）；跟着配音走的字幕条每条 ≥ 1.8s，中文不超过 9 字/秒、英文不超过 20 字符/秒。读的那段时间里，字还在 decode 乱码，或被运动模糊抹花？（真实 UI 截图里的文字、背景纹理文字只要求"看得出是什么"，不要求读完）
+   - 底线只管读一遍，不是舒服的时长。停多久舒服是默认口味，跟着片子的节奏走：BRIEF 的 `Pace`（relaxed / normal / brisk，默认 normal）定目标，各档读速见 `playbook/03-motion-design.md` §2。观众已经知道的字（字幕说的正是画面刚演过的、术语卡第二次出现）和镜头在走时只起提示作用的短标签（标 `data-read="label"`）按 brisk；卡在音乐上的字落在小节线上，不为凑秒数拖长；为读时拉长停留，音乐不能跟着停。
+   - 有时间表就跑 `bin/vh readcheck`：低于底线是 FAIL，要修；只低于 Pace 的目标是 WARN，看一眼是不是有意为之，不算这一条 FAIL。
 6. 【底线】字号低于 BRIEF `Watch on` 那一档的下限（`playbook/03-motion-design.md` §4，1080p 合成里的 px：phone 主标题 84 / 辅助 44 / 字幕 65，desktop 84 / 44 / 48，feed 150 / 80 / 115；出 4K 照常按 1080p 写，渲染时放大）？按最终成片里的实际大小量：镜头推近后以推近后为准，而且推近后字不能发虚（被放大的元素挂着 CSS `will-change` 时，浏览器会把小尺寸的位图直接放大）；Manim 等不以 px 定义字号的引擎，从 1080p 成片的 crop 上量像素。GIF 预览不在考核范围内。
 7. 用了不止一个无衬线族？用斜体做强调？每个词都在强调？
 8. 有写着剧情的牌子、标签、说明文字，而本可以用画面演出来？
@@ -93,12 +95,21 @@ ffmpeg -i out.mp4 -vf "blackdetect=d=0.3,freezedetect=d=1.5" -af silencedetect=d
 
 - **过线**：每个维度都 ≥ 8 才算过，不看平均分。
 - **立意一项分低时**：它打的是"人选定的立意有没有落到画面上"，修法是让画面更贴着立意（主体、首尾、那个装置），不是换立意。reviewer 觉得立意本身就弱，写进关卡 ③ 的"最不满意"，由人决定；agent 不自己换立意。
-- **轮数按努力程度（CLAUDE.md"努力程度"）**：`quick` 不做打分层；`standard` 做 1 轮，修最差的 3 处；`studio` 按下面的规则至少 3 轮。
-- **至少 3 轮（`studio`）**：每轮 reviewer 只列最差的 3 个问题，每个都写时间点和一条可以直接执行的改法；作者只重渲受影响的时间段，改完开下一轮（换一个全新上下文）。第一轮就全部过线也要跑满，分数在不同 reviewer 手里稳住才算数。跑满 3 轮仍有维度低于 8，就把分数和剩下的问题带进关卡 ③，让人决定。
-- **两层的关系**：任何一条 FAIL 没修，分数再高也不能交付；20 条全 PASS 但有维度低于 8，同样要返工。
-- **来源**：社区做法，主要是 Movez 在 X 上的课程 *How to build motion design studio with Opus 5.5* 和 Eian 的中文指南（经社区调研转述）：让 agent 扮演严苛的导演而不是作者，按维度打分，多轮返工。原来的七个维度、≥ 8 分和 3 轮都是那边的经验值，原文没能逐条核实。"立意"一项是本仓库 2026-10-02 加的：`cases/oneshot-five.md` 拆的五支片子赢在点子，不在打磨，而原来的七项里没有一项问点子。
-
-每轮打分同样写进 `NOTES.md`：
+- **轮数按努力程度（CLAUDE.md"努力程度"）**：`quick` 不做打分层；`standard` 做 1 轮，修最差的 3 处；`studio` 按下面的规则至少 3 轮，最多 10 轮。
+- **至少 3 轮（`studio`）**：每轮 reviewer 只列最差的 3 个问题，每个都写时间点和一条可以直接执行的改法；作者只重渲受影响的时间段，改完开下一轮（换一个全新上下文）。第一轮就全部过线也要跑满，分数在不同 reviewer 手里稳住才算数。跑满 3 轮仍有维度低于 8，可以接着修、接着评，但守下面的上限；到了上限还没过线，就把分数和剩下的问题带进关卡 ③，让人决定。
+- **整片评审最多 10 轮**：整片评审指一个全新上下文的 reviewer 看完整片、打满 8 项分；下面说的局部复查不算。到 10 轮就停，不开第 11 轮：过线就交付，没过线就带着最后一轮的分数和剩下的问题进关卡 ③（授权无人值守时，随成片一起交给人）。人在关卡 ③ 退回、提了新的修改意见，轮数和问题计数都从头算；agent 自己决定的重做不从头算。
+- **同一类问题最多改 5 次**：同一类问题指同一条清单条目落在同一个镜头或段落上，例如"卫星那段的 #5 读时""结尾的构图"。改一次、查一次算一次，不论是局部复查还是整片评审查出来的。第 5 次还没解决，就不再来回改：写进 `NOTES.md` 的"已知局限"，附最后一次的证据（帧、strip 或检查输出），交给人定。底线条目到了上限也交给人，人决定删字、换做法还是接受；人拍板之前不出 final。
+- **小修不开整片评审**：局部改动只做局部复查，改了哪段就查哪段。局部改动比如一条标签的时间或字号、在安全框里挪一挪、一个音效的音量、一个镜头的排版。局部复查是三样：
+  - 这一段的帧和 strip；
+  - 覆盖这一段的自动检查：`bin/vh readcheck`、`bin/vh qa`、`bin/vh sheet`，还有静默故障扫描、`hyperframes snapshot` 这类；
+  - 作者自己看一遍。
+
+  新开一轮整片评审只为两种情况：结构性的改动（几个小节一起重排时间、重写一个场景、换一个结尾），或者最后一遍。`studio` 的前 3 轮不受这条限制。
+- **后一轮推翻前一轮**：不同的 reviewer 会互相打架，这一轮嫌停留太长，下一轮嫌太短；这一轮要更亮，下一轮嫌刺眼。口味条目（没标【底线】的）上后一轮和前一轮说法相反时，作者可以保留前一轮的决定，在 `DECISIONS.md` 记一行为什么，不算没修；这一行和口味覆盖一起给下一轮 reviewer 看。底线条目照常要 PASS。
+- **两层的关系**：任何一条 FAIL 没修，分数再高也不能交付；20 条全 PASS 但有维度低于 8，同样要返工。返工都在上面的上限之内。
+- **来源**：社区做法，主要是 Movez 在 X 上的课程 *How to build motion design studio with Opus 5.5* 和 Eian 的中文指南（经社区调研转述）：让 agent 扮演严苛的导演而不是作者，按维度打分，多轮返工。原来的七个维度、≥ 8 分和 3 轮都是那边的经验值，原文没能逐条核实。"立意"一项是本仓库 2026-10-02 加的：`cases/oneshot-five.md` 拆的五支片子赢在点子，不在打磨，而原来的七项里没有一项问点子。10 轮和 5 次的上限是 2026-10-04 加的：一支 `studio` 片子跑了 11 轮整片评审，每个新 reviewer 都挑出新的口味小毛病，分数在 7–9 之间来回，小修有时还把别处改坏了。维护者的原话："每一种问题不超过5次，总共不超过10次，不要为了一个小问题就全部来一遍Review。"
+
+每轮整片评审在 `NOTES.md` 的"评审记录"记一行：第几轮、八项分数、改了什么；同一类问题在"问题计数"表里加一次（格式写在 NOTES.md 那一节的注释里）。reviewer 的报告可以附在那一行下面，长这样：
 
 ```text
 [score round 2 · draft5] fresh-context reviewer, harsh motion director · sheets: out/check/phone_*.png, out/check/sheet.png
diff --git a/tools/ci.sh b/tools/ci.sh
index b87bd9a..4f782f4 100755
--- a/tools/ci.sh
+++ b/tools/ci.sh
@@ -287,17 +287,31 @@ decision_checks() {
   vh style apply no-such-style "$p" >/dev/null 2>&1; rc=$?; [ $rc = 1 ] && ok "style apply rejects an unknown preset" || bad "style apply unknown preset exited $rc"
   # readcheck: a budget, and the timed text of a composition without a browser
   a=$(vh readcheck --budget 3.2)
-  case "$a" in *"up to 7 CJK"*"up to 28 CJK"*) ok "readcheck --budget" ;; *) bad "readcheck --budget 3.2 said: $a" ;; esac
+  case "$a" in *"normal pace"*"up to 14 CJK"*"one brisk read"*"up to 16 CJK"*"up to 28 CJK"*) ok "readcheck --budget: the pace's target, the floor, subtitles" ;; *) bad "readcheck --budget 3.2 said: $a" ;; esac
+  # no fixed seconds: under one brisk read (CJK/7 + other/20 + 0.8 s, at least 1.5 s) FAILs; under the pace's target only WARNs
   tl=$(mktemp -d "${TMPDIR:-/tmp}/vh-ci.XXXXXX")
-  printf '%s' '[{"id":"a","text":"CLAUDE.md router","start":0,"end":1.7,"read":"label"},{"id":"b","text":"CLAUDE.md router","start":0,"end":1.7}]' > "$tl/label.json"
-  a=$(vh readcheck "$tl/label.json"); rc=$?; rm -rf "$tl"
-  case "$rc:$a" in 1:*"OK  a"*"lab"*"BAD b"*) ok "readcheck: a short label (data-read=label) needs one read, unmarked text the on-screen floor" ;; *) bad "readcheck label rule (rc $rc): $a" ;; esac
+  printf '%s' '[{"id":"a","text":"CLAUDE.md router","start":0,"end":1.6,"read":"label"},{"id":"b","text":"CLAUDE.md router","start":0,"end":1.6},' \
+    '{"id":"c","text":"CLAUDE.md router","start":0,"end":1.6,"pace":"brisk"}]' > "$tl/label.json"
+  a=$(vh readcheck "$tl/label.json"); rc=$?
+  case "$rc:$a" in 0:*"OK   a"*"lab"*"WARN b"*"normal  1.63s"*"OK   c"*"pace normal, default"*"3/3 pass · 1 WARN"*)
+      ok "readcheck: under the pace's target is a WARN (exit 0); a label and a brisk text need one read" ;; *) bad "readcheck WARN band (rc $rc): $a" ;; esac
+  printf '%s' '[{"id":"f","text":"CLAUDE.md router","start":0,"end":1.2},{"id":"g","text":"短","start":2,"end":2.9}]' > "$tl/flash.json"
+  a=$(vh readcheck "$tl/flash.json"); rc=$?
+  case "$rc:$a" in 1:*"FAIL f"*"floor  1.55s"*"FAIL g"*"floor  1.50s"*"2 FAIL"*) ok "readcheck: under the floor FAILs, and nothing passes under 1.5 s" ;; *) bad "readcheck floor (rc $rc): $a" ;; esac
+  printf '%s\n' '# BRIEF' '- Pace: relaxed  <!-- relaxed | normal | brisk -->' > "$tl/BRIEF.md"
+  a=$(vh readcheck "$tl/label.json"); b=$(vh readcheck "$tl/label.json" --pace brisk); rc=$?
+  case "$a" in *"WARN b"*"relaxed  2.00s"*"pace relaxed, Pace in"*)
+      case "$rc:$b" in 0:*"OK   b"*"pace brisk, --pace"*) ok "readcheck takes the pace from the BRIEF, and --pace overrides it" ;; *) bad "readcheck --pace brisk (rc $rc): $b" ;; esac ;;
+    *) bad "readcheck with a BRIEF Pace: $a" ;; esac
+  printf '%s' '[{"id":"x","text":"t","start":0,"end":2,"pace":"fast"}]' > "$tl/badpace.json"
+  vh readcheck "$tl/badpace.json" >/dev/null 2>&1; rc=$?; rm -rf "$tl"
+  [ $rc = 2 ] && ok "readcheck refuses a pace that is not relaxed, normal or brisk" || bad "readcheck with a pace of \"fast\" exited $rc"
   printf '%s\n' '<html><body><div id="root" data-composition-id="m" data-start="0" data-duration="10">' \
     '<section id="s" class="clip" data-start="0" data-duration="10"><h1 id="t">script-driven</h1></section>' \
     '<div id="c1" class="clip" data-start="1" data-duration="4"><span>四个汉字</span></div>' \
     '<div id="c2" class="clip" data-start="6" data-duration="1.2">太短了的字</div></div><script>var x="<div>";</script></body></html>' > "$p/index.html"
   a=$(vh readcheck "$p/index.html"); rc=$?
-  case "$rc:$a" in 1:*"OK  c1"*"BAD c2"*"NOT checked: 1 text block"*) ok "readcheck reads a composition's clips (and says what it left out)" ;; *) bad "readcheck index.html (rc $rc): $a" ;; esac
+  case "$rc:$a" in 1:*"OK   c1"*"FAIL c2"*"pace relaxed, Pace in"*"NOT checked: 1 text block"*) ok "readcheck reads a composition's clips and the new project's Pace (a math project: relaxed; and says what it left out)" ;; *) bad "readcheck index.html (rc $rc): $a" ;; esac
   vh readcheck --export "$p" >/dev/null && grep -q '"id": "c2"' "$p/texts.json" && { vh readcheck "$p" --export >/dev/null 2>&1; [ $? = 2 ]; } \
     && ok "readcheck --export writes texts.json and will not overwrite it" || bad "readcheck --export"
   # HyperFrames timing the way HyperFrames resolves it: "id", "id+n", a sub-composition's <template>, a typo'd reference
diff --git a/tools/readcheck.py b/tools/readcheck.py
index 3c2433f..c851938 100644
--- a/tools/readcheck.py
+++ b/tools/readcheck.py
@@ -1,8 +1,8 @@
 """Reading-time check: is every text on screen long enough to be read?
 
-usage: python3 tools/readcheck.py <texts.json | project_dir | composition.html> [--mode onscreen|label|subtitle] [--lang zh|en]
-                                  [--cjk-cps 4.5] [--latin-cps 15] [--pad 1.5] [--min 2.5]
-       python3 tools/readcheck.py --budget <seconds> [--mode …] [--lang …]    how much text fits in a span
+usage: python3 tools/readcheck.py <texts.json | project_dir | composition.html> [--pace relaxed|normal|brisk]
+                                  [--mode onscreen|label|subtitle] [--lang zh|en] [--cjk-cps N] [--latin-cps N] [--pad S] [--min S]
+       python3 tools/readcheck.py --budget <seconds> [--pace …] [--mode …] [--lang …] [project]   how much text fits in a span
        python3 tools/readcheck.py <composition.html | project_dir> --export [--out texts.json] [--force]
 
 Input: a JSON list of {text, start, end} in seconds (`t0`/`t1` also accepted; `text` may be a list of lines),
@@ -11,28 +11,41 @@
 A directory means <dir>/audio/captions.json. `start` must be the moment the text is fully shown and readable
 (typing, decode and fly-in finished), `end` the moment it starts to leave.
 
-Three rules, templates/TASTE_CHECKLIST.md #5 (rationale in playbook/03-motion-design.md §2):
-  onscreen  (default) titles, labels, number cards that nobody reads aloud: minimum time on screen
-            need = max(--min, CJK chars / --cjk-cps + other non-space chars / --latin-cps + --pad)
-            defaults 4.5 CJK chars/s, 15 chars/s, pad 1.5 s, floor 2.5 s.
-  label     a short label in a moving shot, there to point at something, read once: need = max(1.5 s, CJK chars / 7
-            + other non-space chars / 20 + 0.8 s). For tags, node names, captions on a passing gate; a sentence the viewer
-            must take away (a claim, a number to remember) stays on the on-screen rule. Mark it data-read="label".
-  subtitle  lines that follow the voice: reading-speed ceiling, plus a 1.8 s floor
+No fixed seconds: on-screen text has a floor and a target (templates/TASTE_CHECKLIST.md #5, playbook/03-motion-design.md §2).
+  seconds at a pace = CJK chars / CJK rate + other non-space chars / other rate + pad; mixed zh/en lines count both.
+  floor     one read at a brisk speed, any film: max(1.5 s, CJK/7 + other/20 + 0.8 s), #53's short-label rule (1.5 s: no flash).
+            Below it the text FAILs (exit 1).
+  target    the film's pace, a taste default: the BRIEF's "- Pace:" line, else normal; --pace overrides it.
+              relaxed  CJK/4.5 + other/15 + 1.0 s     explainers, papers, letters: the viewer reads and thinks
+              normal   CJK/6   + other/18 + 0.8 s     most films
+              brisk    CJK/7   + other/20 + 0.8 s     fast cuts, memes, beat-cut MVs; the same as the floor
+            Below it (but over the floor) the text gets a WARN, exit 0: a look, not a fix list. --cjk-cps, --latin-cps,
+            --pad and --min retune the target for one run; the floor never moves.
+
+Three kinds of text:
+  onscreen  (default) titles, claims, number cards that nobody reads aloud: the floor, and the film's pace as the target.
+  label     a short label in a moving shot, there to point at something (node names, station names, a gate's caption):
+            its target is brisk, i.e. one read. Mark it data-read="label". A sentence the viewer must take away stays
+            onscreen.
+  subtitle  lines that follow the voice: reading-speed ceiling, plus a 1.8 s floor; the voice sets the pace
             CJK text ≤ 9 chars/s (half-width characters count 0.5), Latin text ≤ 20 chars/s (spaces and punctuation count)
 
 Per text: spoken captions that repeat the narration are subtitles, whatever the run's default. A timed element of a
 HyperFrames composition carrying data-read="subtitle", on the clip itself or on a clip or scene around it (a
 sub-composition's host included), is checked with the subtitle rule; everything else stays on the on-screen rule.
 data-read="label" uses the label rule; data-read="onscreen" says the default aloud, and the nearest mark wins, so one
-text can opt out of a marked scene.
-Marked texts get a `sub` or `lab` tag in the output and count in the totals. A texts.json item takes the same key,
-"read": "subtitle" or "label" (--export writes it). --mode is the rule for texts that carry no mark; a mark always wins over it.
-
-The onscreen formula comes from lemo-opuscar's core/render/readcheck.mjs and DIRECTOR.md §7 (MIT, © 2026 LemoLab);
-the floor is ours (2.5 s). The label rule is ours too (2026-10-04, from the intro film: holds that met the on-screen
-rule everywhere made a promo drag, so short labels get one read). The subtitle ceilings are the Netflix Timed Text Style Guide figures for adult programmes
-(Chinese Simplified 9 cps, English USA 20 cps); the 1.8 s floor is lemo's DIRECTOR.md §7.
+text can opt out of a marked scene. data-pace="relaxed|normal|brisk" works the same way and changes the target of
+the texts under it (a brisk montage in a normal film; text the viewer already knows, such as a caption saying what the
+picture just showed, may run at brisk).
+Marked texts get a `sub` or `lab` tag in the output and count in the totals. A texts.json item takes the same keys,
+"read": "subtitle" or "label" and "pace": "brisk" (--export writes them). --mode is the rule for texts that carry no
+mark; a mark always wins over it.
+
+The shape of the on-screen formula (characters / rate + pad) comes from lemo-opuscar's core/render/readcheck.mjs and
+DIRECTOR.md §7 (MIT, © 2026 LemoLab), whose 4.5 CJK / 15 other chars a second the relaxed pace keeps. The floor, the
+paces are ours (2026-10-04: a fixed 2.5 s minimum and a 1.5 s pad made fast films drag; the maintainer asked for no
+hard-coded intervals); the floor is the short-label rule the intro film was cut to (#53). The subtitle ceilings are the Netflix Timed Text Style Guide figures for
+adult programmes (Chinese Simplified 9 cps, English USA 20 cps); the 1.8 s floor is lemo's DIRECTOR.md §7.
 lemo's tool renders the page and asks window.TEXTS(t) for boxes; this one only reads timings, so it cannot see
 cropping or text that leaves the frame. Check those on the contact sheet.
 
@@ -46,11 +59,12 @@
 Left out, and counted: text in a clip as long as the whole film (the usual "draw(t)" script decides when it shows),
 and clips whose data-start resolves to nothing (HyperFrames silently puts those at 0).
 
---budget <seconds> answers the question before the text exists: how many characters fit in that span, by the same
-rules (on-screen, subtitle), plus the spoken estimate for Chinese narration from playbook/04-audio.md (4.5–5.5 字/s
+--budget <seconds> answers the question before the text exists: how many characters fit in that span, at the pace
+and at the floor, as a subtitle, plus the spoken estimate for Chinese narration from playbook/04-audio.md (4.5–5.5 字/s
 for a knowledge short, 3.5–4.5 for an explainer or a paper, within a sentence; x 0.85 for the pauses).
 
-Exit: 0 all pass · 1 some too short / too fast · 2 nothing to check (bad input). Writes nothing, except --export.
+Exit: 0 nothing under the floor (WARNs allowed) · 1 some text under the floor / subtitles too fast · 2 nothing to
+check (bad input). Writes nothing, except --export.
 """
 import argparse, json, math, os, re, subprocess, sys
 from collections import Counter
@@ -60,8 +74,11 @@
 CJK_RANGES = [(0x3040, 0x30FF), (0x31F0, 0x31FF), (0x3400, 0x4DBF), (0x4E00, 0x9FFF), (0xF900, 0xFAFF),
               (0xAC00, 0xD7AF), (0x1100, 0x11FF), (0x3130, 0x318F), (0x20000, 0x2FA1F)]   # kana, Han, Hangul
 SUB_FLOOR, SUB_CPS_CJK, SUB_CPS_LATIN = 1.8, 9.0, 20.0
-LABEL_FLOOR, LABEL_CPS_CJK, LABEL_CPS_LATIN, LABEL_PAD = 1.5, 7.0, 20.0, 0.8   # a short label, read once
+# reading paces: (CJK chars/s, other non-space chars/s, pad s); playbook/03-motion-design.md §2 says why these numbers
+PACES = {"relaxed": (4.5, 15.0, 1.0), "normal": (6.0, 18.0, 0.8), "brisk": (7.0, 20.0, 0.8)}
+FLOOR_PACE, FLOOR_MIN, DEFAULT_PACE = "brisk", 1.5, "normal"   # the floor: one brisk read, never under 1.5 s (a flash)
 TAGS = {"subtitle": "sub", "onscreen": "on", "label": "lab"}   # the tag column of a run that mixes rules
+STATUS = {"ok": "OK  ", "warn": "WARN", "fail": "FAIL"}   # WARN: over the floor, under the pace's target
 PAUSE = 0.85   # playbook/04-audio.md: script length = seconds x rate x 0.85, the rest is pauses between sentences
 LAST_STATS = {}   # what the last composition read left out (export_html)
 
@@ -88,9 +105,37 @@ def read_mode(v):
     v = re.sub(r"[\s_-]", "", str(v or "")).lower()
     return v if v in ("subtitle", "onscreen", "label") else None
 
+def pace_name(v):
+    """"relaxed" / "normal" / "brisk" from a Pace line, a data-pace or a "pace" value (case and spaces are ignored); None otherwise."""
+    v = re.sub(r"\s", "", str(v or "")).lower()
+    return v if v in PACES else None
+
+def find_pace(path):
+    """(pace, brief, raw): the "- Pace:" line of the nearest BRIEF.md at or above path. pace is None when there is no
+    BRIEF.md, no Pace line (raw None) or a value that names no pace (raw is that value)."""
+    if path is None:
+        return None, None, None
+    d = Path(path).resolve()
+    d = d if d.is_dir() else d.parent
+    while True:
+        brief = d / "BRIEF.md"
+        if brief.is_file():
+            m = re.search(r"(?m)^\s*[-*]\s*Pace\s*[:：]\s*([^<\n]*)", brief.read_text(encoding="utf-8", errors="replace"))
+            if not m:
+                return None, brief, None
+            raw = m.group(1).strip()
+            return pace_name(raw), brief, raw
+        if d.parent == d:
+            return None, None, None
+        d = d.parent
+
+def settings(pace=DEFAULT_PACE, cjk_cps=None, latin_cps=None, pad=None, min=None):
+    """The run settings verdict() and budget() read: the film's pace and the overrides of its target (None: the pace's)."""
+    return argparse.Namespace(pace=pace, cjk_cps=cjk_cps, latin_cps=latin_cps, pad=pad, min=min, mode=None, lang=None)
+
 def pieces(items, lang):
-    """Yield (label, start, end, text, mode) for every text to check; mode is the item's own rule ("subtitle" /
-    "onscreen" from its "read" key) or None, which means the run's default."""
+    """Yield (label, start, end, text, mode, pace) for every text to check; mode is the item's own rule ("subtitle" /
+    "onscreen" / "label" from its "read" key) and pace its own pace ("pace" key), None for the run's."""
     for i, it in enumerate(items):
         t0, t1 = it.get("start", it.get("t0")), it.get("end", it.get("t1"))
         if t0 is None or t1 is None:
@@ -99,6 +144,9 @@ def pieces(items, lang):
         mode = read_mode(it.get("read"))
         if it.get("read") not in (None, "") and mode is None:
             raise ValueError(f"item {label}: \"read\" is {it['read']!r}; use \"subtitle\", \"onscreen\" or \"label\"")
+        pace = pace_name(it.get("pace"))
+        if it.get("pace") not in (None, "") and pace is None:
+            raise ValueError(f"item {label}: \"pace\" is {it['pace']!r}; use \"relaxed\", \"normal\" or \"brisk\"")
         if "text" in it:
             fields = [("", it["text"])]
         else:
@@ -109,17 +157,31 @@ def pieces(items, lang):
                 txt = ("" if any(is_cjk(c) for c in "".join(map(str, txt))) else " ").join(map(str, txt))
             txt = str(txt)
             if txt.strip():
-                yield (f"{label}{'·' + k if k else ''}", float(t0), float(t1), txt, mode)
+                yield (f"{label}{'·' + k if k else ''}", float(t0), float(t1), txt, mode, pace)
 
-def onscreen_need(text, a):
+def seconds_at(text, cjk_cps, latin_cps, pad):
+    """CJK chars / cjk_cps + other non-space chars / latin_cps + pad."""
     cjk = sum(1 for c in text if is_cjk(c))
     other = sum(1 for c in text if not c.isspace() and not is_cjk(c))
-    return max(a.min, cjk / a.cjk_cps + other / a.latin_cps + a.pad)
-
-def label_need(text):
-    cjk = sum(1 for c in text if is_cjk(c))
-    other = sum(1 for c in text if not c.isspace() and not is_cjk(c))
-    return max(LABEL_FLOOR, cjk / LABEL_CPS_CJK + other / LABEL_CPS_LATIN + LABEL_PAD)
+    return cjk / cjk_cps + other / latin_cps + pad
+
+def floor_need(text):
+    """The floor (TASTE_CHECKLIST #5): one read at a brisk speed, never under FLOOR_MIN."""
+    return max(FLOOR_MIN, seconds_at(text, *PACES[FLOOR_PACE]))
+
+def pace_rule(a, pace=None):
+    """(CJK rate, other rate, pad, minimum) of a pace: a text's own pace as it is, the run's (a.pace) with its overrides."""
+    run = getattr(a, "pace", None) or DEFAULT_PACE
+    if pace and pace != run:
+        return (*PACES[pace], 0.0)
+    cjk, lat, pad = PACES[run]
+    o = lambda k: getattr(a, k, None)
+    return (o("cjk_cps") or cjk, o("latin_cps") or lat, pad if o("pad") is None else o("pad"), o("min") or 0.0)
+
+def target_need(text, a, pace=None):
+    """The comfortable time at the pace (a taste default), never under the floor."""
+    cjk, lat, pad, lo = pace_rule(a, pace)
+    return max(floor_need(text), lo, seconds_at(text, cjk, lat, pad))
 
 def subtitle_check(text, dur):
     if any(is_cjk(c) for c in text):   # Netflix CJK rule: half-width characters count 0.5
@@ -129,13 +191,16 @@ def subtitle_check(text, dur):
     need = max(SUB_FLOOR, n / limit)
     return need, n / dur if dur > 0 else float("inf"), limit
 
-def verdict(text, dur, mode, a):
-    """(ok, need, rate, limit): one text against the rule of its mode; rate and limit are None for the on-screen rule."""
+def verdict(text, dur, mode, a, pace=None):
+    """(state, need, target, rate, limit): one text against the rule of its mode. state is "ok", "warn" (over the
+    floor, under the pace's target) or "fail"; need is the floor (a subtitle: its own rule), target the time at the
+    text's pace (a label: brisk, the floor; None for a subtitle); rate and limit only for a subtitle."""
     if mode == "subtitle":
         need, rate, limit = subtitle_check(text, dur)
-        return dur >= need - 1e-6, need, rate, limit
-    need = label_need(text) if mode == "label" else onscreen_need(text, a)
-    return dur >= need - 1e-6, need, None, None
+        return ("ok" if dur >= need - 1e-6 else "fail"), need, None, rate, limit
+    need = floor_need(text)
+    target = need if mode == "label" else target_need(text, a, pace)
+    return ("fail" if dur < need - 1e-6 else "warn" if dur < target - 1e-6 else "ok"), need, target, None, None
 
 # ---------- on-screen text straight from a HyperFrames composition ----------
 VOID = {"area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "source", "track", "wbr", "param"}
@@ -249,17 +314,18 @@ def _timeline(html):
             spans[(str(row.get("file") or "index.html"), str(ident))] = (a, b)
     return spans
 
-def _mark(n, inherit):
-    """(mode, raw) from the nearest data-read on n or above it, else (inherit, None); mode is None when raw is no known rule."""
+def _mark(n, inherit, attr="data-read", parse=read_mode):
+    """(value, raw) from the nearest attr (data-read, data-pace) on n or above it, else (inherit, None); value is None
+    when raw names nothing known."""
     while n is not None:
-        if "data-read" in n.attrs:
-            return read_mode(n.attrs["data-read"]), n.attrs["data-read"]
+        if attr in n.attrs:
+            return parse(n.attrs[attr]), n.attrs[attr]
         n = n.parent
     return inherit, None
 
-def _export(path, base, offset, until, depth, tl, stats, items, read=None):
+def _export(path, base, offset, until, depth, tl, stats, items, read=None, pace=None):
     """The timed text of one composition file, its sub-compositions included, offset by the host's start.
-    `read` is the rule a host clip's data-read hands down to a sub-composition."""
+    `read` and `pace` are what a host clip's data-read and data-pace hand down to a sub-composition."""
     root = _Tree(); root.feed(path.read_text(encoding="utf-8", errors="replace")); root.close(); root = root.root
     if depth:   # a sub-composition is built from its file's <template>, when it has one
         root = next((n for n in _elements(root, True) if n.tag == "template"), root)
@@ -321,7 +387,7 @@ def span(n):   # absolute (start, shown until, own end or None); None when the s
             if depth < 4 and sub.is_file():
                 inner = _export_dur(sub)
                 end = b if k.attrs.get("data-duration") or k.attrs.get("data-end") else (a + inner if inner is not None else b)
-                _export(sub, base, a, end, depth + 1, tl, stats, items, _mark(k, read)[0])
+                _export(sub, base, a, end, depth + 1, tl, stats, items, _mark(k, read)[0], _mark(k, pace, "data-pace", pace_name)[0])
             else:
                 stats["unresolved"].append(f"{rel}#{k.attrs.get('id') or k.tag}: sub-composition {src} not found")
             continue
@@ -337,6 +403,9 @@ def span(n):   # absolute (start, shown until, own end or None); None when the s
             mode, raw = _mark(node, read)
             if mode: it["read"] = mode
             elif raw is not None: stats["badread"].append(f"{rel}#{ident}: data-read=\"{raw}\"")
+            pm, raw = _mark(node, pace, "data-pace", pace_name)
+            if pm: it["pace"] = pm
+            elif raw is not None: stats["badread"].append(f"{rel}#{ident}: data-pace=\"{raw}\"")
             if node is not k:   # the span is the enclosing clip's (a scene), not a timing of the text's own
                 it["clip"] = k.attrs.get("id") or k.tag
             items.append(it)
@@ -354,8 +423,9 @@ def composition_duration(html):
 def export_html(path):
     """(items, stats): the composition's timed text [{id, text, start, end, from, clip?}], and stats = {"untimed": text
     blocks left out because a clip as long as the whole film holds them, "unresolved": data-start values nothing
-    resolves (HyperFrames puts those at 0), "badread": data-read values that name no rule, "source": where the
-    spans came from}. An item carries "read": "subtitle" / "onscreen" when its clip, or a clip around it, is marked."""
+    resolves (HyperFrames puts those at 0), "badread": data-read / data-pace values that name nothing, "source": where
+    the spans came from}. An item carries "read" ("subtitle" / "onscreen" / "label") and "pace" when its clip, or a clip
+    around it, is marked."""
     path = Path(path)
     tl = _timeline(path)
     stats = {"untimed": 0, "unresolved": [], "zeroed": [], "badread": [], "source": "HyperFrames' own timeline" if tl is not None else "the HTML (no hyperframes in the project to ask)"}
@@ -379,59 +449,82 @@ def zeroed_note(stats):
 
 def badread_note(stats):
     b = stats.get("badread") or []
-    return (f"{len(b)} text(s) have a data-read that is not \"subtitle\", \"onscreen\" or \"label\", so they were checked as on-screen text: "
+    return (f"{len(b)} text(s) have a data-read that is not \"subtitle\", \"onscreen\" or \"label\", or a data-pace that is not "
+            "\"relaxed\", \"normal\" or \"brisk\", so they were checked as on-screen text at the film's pace: "
             + "; ".join(b[:4]) + (" …" if len(b) > 4 else "")) if b else ""
 
 def budget(span, a):
     """Lines saying how much text fits in span seconds."""
     rows = [f"readcheck budget for {span:.2f} s"]
-    if a.mode in (None, "onscreen"):
-        avail = span - a.pad
-        if span < a.min - 1e-9 or avail <= 0:
-            rows.append(f"  on-screen text (nobody reads it aloud): nothing: {span:.2f} s is under the {a.min:g} s floor")
+    def fits(name, cjk, lat, pad, lo, how):
+        avail = span - pad
+        if span < lo - 1e-9 or avail <= 0:
+            why = f"under the {lo:g} s minimum" if span < lo - 1e-9 else f"no longer than the {pad:g} s pad"
+            rows.append(f"  {name:<44} nothing: {span:.2f} s is {why}")
         else:
-            cjk, lat = math.floor(avail * a.cjk_cps + 1e-9), math.floor(avail * a.latin_cps + 1e-9)
-            rows.append(f"  on-screen text (nobody reads it aloud): up to {cjk} CJK characters, or {lat} other characters"
-                        f"  [({span:.2f} - {a.pad:g} s) x {a.cjk_cps:g} / {a.latin_cps:g} per s; floor {a.min:g} s; mixed: CJK/{a.cjk_cps:g} + other/{a.latin_cps:g} <= {avail:.2f}]")
-    if a.mode in (None, "label"):
-        avail = span - LABEL_PAD
-        if span < LABEL_FLOOR - 1e-9:
-            rows.append(f"  label (short, read once):               nothing: {span:.2f} s is under the {LABEL_FLOOR:g} s floor")
-        else:
-            rows.append(f"  label (short, read once):               up to {math.floor(avail * LABEL_CPS_CJK + 1e-9)} CJK characters, or "
-                        f"{math.floor(avail * LABEL_CPS_LATIN + 1e-9)} other characters  [({span:.2f} - {LABEL_PAD:g} s) x {LABEL_CPS_CJK:g} / {LABEL_CPS_LATIN:g} per s; floor {LABEL_FLOOR:g} s]")
+            rows.append(f"  {name:<44} up to {math.floor(avail * cjk + 1e-9)} CJK characters, or {math.floor(avail * lat + 1e-9)} other characters"
+                        f"  [({span:.2f} - {pad:g} s) x {cjk:g} / {lat:g} per s{how}; mixed: CJK/{cjk:g} + other/{lat:g} <= {avail:.2f}]")
+    if a.mode in (None, "onscreen"):
+        cjk, lat, pad, lo = pace_rule(a)
+        lo = max(lo, FLOOR_MIN)   # the target is never under the floor
+        fits(f"on-screen text, {a.pace} pace (the target):", cjk, lat, pad, lo, f"; never under {lo:g} s")
+    if a.mode in (None, "onscreen", "label"):
+        fits("the floor, one brisk read (also labels):", *PACES[FLOOR_PACE], FLOOR_MIN, f"; never under {FLOOR_MIN:g} s")
     if a.mode in (None, "subtitle"):
         if span < SUB_FLOOR - 1e-9:
-            rows.append(f"  subtitle (follows the voice):           nothing: {span:.2f} s is under the {SUB_FLOOR:g} s floor")
+            rows.append(f"  {'subtitle (follows the voice):':<44} nothing: {span:.2f} s is under the {SUB_FLOOR:g} s floor")
         else:
-            rows.append(f"  subtitle (follows the voice):           up to {math.floor(span * SUB_CPS_CJK + 1e-9)} CJK characters (half-width count 1/2), "
+            rows.append(f"  {'subtitle (follows the voice):':<44} up to {math.floor(span * SUB_CPS_CJK + 1e-9)} CJK characters (half-width count 1/2), "
                         f"or {math.floor(span * SUB_CPS_LATIN + 1e-9)} Latin characters with spaces  [x {SUB_CPS_CJK:g} / {SUB_CPS_LATIN:g} per s; floor {SUB_FLOOR:g} s]")
     if a.lang in (None, "zh"):   # playbook/04-audio.md, "旁白要导演": rates within a sentence, x 0.85 for the pauses between sentences
         f = lambda r: math.floor(span * r * PAUSE + 1e-9)
-        rows.append(f"  narration, Chinese (spoken):            knowledge short about {f(4.5)}-{f(5.5)} characters, explainer or paper about {f(3.5)}-{f(4.5)}"
+        rows.append(f"  {'narration, Chinese (spoken):':<44} knowledge short about {f(4.5)}-{f(5.5)} characters, explainer or paper about {f(3.5)}-{f(4.5)}"
                     f"  [playbook/04-audio.md: 4.5-5.5 / 3.5-4.5 per s within a sentence, x {PAUSE:g} for the pauses; measure with a draft bin/vh tts]")
     return rows
 
+def pace_source(a):
+    """Set a.pace (--pace, else the BRIEF's Pace line, else normal) and say where it came from."""
+    if a.pace:
+        return "--pace"
+    pace, brief, raw = find_pace(a.path)
+    shown = brief and (os.path.relpath(brief) if not os.path.relpath(brief).startswith("..") else str(brief))
+    if pace:
+        a.pace = pace
+        return f"Pace in {shown}"
+    a.pace = DEFAULT_PACE
+    if raw:
+        return f"default; {shown} says Pace: {raw!r}, which is not relaxed, normal or brisk"
+    return f"default; no Pace line in {shown}" if brief else "default"
+
 def main():
-    ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
-    ap.add_argument("path", type=Path, nargs="?")
-    ap.add_argument("--mode", choices=("onscreen", "label", "subtitle"))
+    parts = __doc__.split("\n\n")   # -h: the usage, the two rules, the kinds of text and the exit codes
+    ap = argparse.ArgumentParser(prog="bin/vh readcheck", formatter_class=argparse.RawDescriptionHelpFormatter,
+                                 description="\n\n".join(x for x in parts if x.startswith(("Reading-time", "No fixed", "Three kinds", "Exit:"))),
+                                 epilog="data-read and data-pace marks, compositions and --budget: the top of tools/readcheck.py.")
+    ap.add_argument("path", type=Path, nargs="?", help="a texts.json, a project folder (its audio/captions.json) or a composition .html")
+    ap.add_argument("--pace", choices=tuple(PACES), help="the film's reading pace (default: the BRIEF's Pace line, else normal)")
+    ap.add_argument("--mode", choices=("onscreen", "label", "subtitle"), help="the rule for texts without a data-read mark (default onscreen)")
     ap.add_argument("--budget", type=float, metavar="SECONDS", help="how many characters fit in a span of this length")
     ap.add_argument("--export", action="store_true", help="write the composition's timed text as JSON (to --out, default "
                     "<project>/texts.json) instead of checking it")
     ap.add_argument("--out", type=Path, help="where --export writes (a file, or a folder for texts.json in it)")
     ap.add_argument("--force", action="store_true", help="--export may overwrite an existing file")
-    ap.add_argument("--lang", choices=("zh", "en"))
-    ap.add_argument("--cjk-cps", type=float, default=4.5)
-    ap.add_argument("--latin-cps", type=float, default=15.0)
-    ap.add_argument("--pad", type=float, default=1.5)
-    ap.add_argument("--min", type=float, default=2.5)
+    ap.add_argument("--lang", choices=("zh", "en"), help="check one language of a bilingual captions.json")
+    ap.add_argument("--cjk-cps", type=float, help="retune the target: CJK characters a second (the floor does not move)")
+    ap.add_argument("--latin-cps", type=float, help="retune the target: other non-space characters a second")
+    ap.add_argument("--pad", type=float, help="retune the target: seconds added to every text")
+    ap.add_argument("--min", type=float, help="retune the target: a minimum in seconds")
     a = ap.parse_args()
-    if a.cjk_cps <= 0 or a.latin_cps <= 0:
+    if any(v is not None and not (v > 0 and math.isfinite(v)) for v in (a.cjk_cps, a.latin_cps)):
         ap.error("--cjk-cps and --latin-cps must be > 0")
+    if any(v is not None and not (v >= 0 and math.isfinite(v)) for v in (a.pad, a.min)):
+        ap.error("--pad and --min must be >= 0 seconds")
     if a.budget is not None:
         if not a.budget > 0 or not math.isfinite(a.budget): ap.error("--budget must be > 0 seconds")
-        print("\n".join(budget(a.budget, a))); sys.exit(0)
+        src = pace_source(a)
+        print("\n".join(budget(a.budget, a)))
+        if a.mode in (None, "onscreen"): print(f"  pace {a.pace} ({src})")
+        sys.exit(0)
     if a.path is None:
         ap.error("give a texts.json, a project folder or a composition .html (or --budget SECONDS)")
     if a.export:
@@ -456,6 +549,7 @@ def main():
         print("  a text that fades in is readable later than its clip starts: move its start to that moment, then bin/vh readcheck " + str(out))
         sys.exit(0)
     a.mode = a.mode or "onscreen"
+    src = pace_source(a)
     try:
         path, items = load_items(a.path)
         todo = list(pieces(items, a.lang))
@@ -466,25 +560,38 @@ def main():
     if not todo:
         print(f"readcheck: NOT CHECKED — no text found in {path}{' (left out: ' + note + ')' if note else ''}. This is not a pass.", file=sys.stderr); sys.exit(2)
 
-    bad, lw = 0, min(14, max(8, max(len(t[0]) for t in todo)))
+    count, lw = Counter(), min(14, max(8, max(len(t[0]) for t in todo)))
     own = Counter(t[4] for t in todo if t[4] and t[4] != a.mode)   # texts whose own mark differs from the run's rule
-    for label, t0, t1, text, mode in todo:
+    paced = False   # did any text go by a pace (not a subtitle)?
+    tuned = any(v is not None for v in (a.cjk_cps, a.latin_cps, a.pad, a.min))   # the run's target retuned by hand
+    for label, t0, t1, text, mode, pace in todo:
         dur = t1 - t0
         mode = mode or a.mode
-        ok, need, rate, limit = verdict(text, dur, mode, a)
-        detail = f"shown {dur:5.2f}s  need {need:5.2f}s" + (f"  ({rate:4.1f}/s, limit {limit:g}/s)" if mode == "subtitle" else "")
-        bad += not ok
+        state, need, target, rate, limit = verdict(text, dur, mode, a, pace)
+        if mode == "subtitle":
+            detail = f"shown {dur:5.2f}s  need  {need:5.2f}s  ({rate:4.1f}/s, limit {limit:g}/s)"
+        elif mode == "label":
+            detail = f"shown {dur:5.2f}s  floor {need:5.2f}s  (a label: one read)"
+            paced = True
+        else:
+            name = "target" if tuned and pace in (None, a.pace) else pace or a.pace
+            detail = f"shown {dur:5.2f}s  floor {need:5.2f}s  {name} {target:5.2f}s"
+            paced = True
+        count[state] += 1
         short = text if len(text) <= 28 else text[:27] + "…"
         tag = f" {TAGS[mode] if mode != a.mode else '':<3}" if own else ""   # a tag column only when some text is not on the run's rule
-        print(f"{'OK ' if ok else 'BAD'} {label:<{lw}}{tag} {t0:7.2f}–{t1:7.2f}s  {detail}  {json.dumps(short, ensure_ascii=False)}")
+        print(f"{STATUS[state]} {label:<{lw}}{tag} {t0:7.2f}–{t1:7.2f}s  {detail}  {json.dumps(short, ensure_ascii=False)}")
     mixed = "".join(f", {n} of {len(todo)} as {m}" for m, n in own.items())
-    print(f"readcheck ({a.mode}{mixed}): {len(todo) - bad}/{len(todo)} pass · {path}")
+    rule = f"{a.mode}{mixed}" + (f"; pace {a.pace}, {src}" if paced else "")
+    tally = f"{len(todo) - count['fail']}/{len(todo)} pass" + (f" · {count['fail']} FAIL" if count["fail"] else "") \
+        + (f" · {count['warn']} WARN (under the {'retuned' if tuned else a.pace} target, over the floor: a look, not a fix list)" if count["warn"] else "")
+    print(f"readcheck ({rule}): {tally} · {path}")
     if is_html:   # never claim everything was checked when something was left out
         print(f"  spans from {LAST_STATS.get('source', 'the composition')}; a text that fades in is readable later than its clip starts")
         print(f"  NOT checked: {note}" if note else "  every timed text in the composition was checked")
         if zeroed_note(LAST_STATS): print(f"  note: {zeroed_note(LAST_STATS)}")
         if badread_note(LAST_STATS): print(f"  note: {badread_note(LAST_STATS)}")
-    sys.exit(1 if bad else 0)
+    sys.exit(1 if count["fail"] else 0)
 
 if __name__ == "__main__":
     main()
diff --git a/tools/rhythm.py b/tools/rhythm.py
index 447078a..358c3bf 100644
--- a/tools/rhythm.py
+++ b/tools/rhythm.py
@@ -10,7 +10,8 @@
   captions    the cues of audio/captions.json: red when bin/vh readcheck --mode subtitle fails (under 1.8 s, or faster
               than 9 CJK / 20 Latin characters a second)
   on-screen   texts.json or out/check/texts.json, else the timed text in index.html (bin/vh readcheck --export): red when
-              the on-screen rule fails (max(2.5 s, CJK/4.5 + other/15 + 1.5 s))
+              under the floor (one brisk read: CJK/7 + other/20 + 0.8 s, never under 1.5 s), amber when only under the
+              target of the BRIEF's Pace (relaxed / normal / brisk; bin/vh readcheck -h has the numbers)
   music       sections, beats (downbeats taller) and hits of audio/music.beats.json (bin/vh music), or --beats
   issues      every red thing again, with its reason, so it can be read without hunting
 Missing inputs just leave their lane out. --segment (a shots.json segment) or --from/--to zooms in: shot boxes then
@@ -21,24 +22,28 @@
 """
 import argparse, math, os, re, sys
 from pathlib import Path
-from types import SimpleNamespace
 from PIL import Image, ImageDraw
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 import vhdraw as V
 import readcheck as RC
 
-ONSCREEN = SimpleNamespace(min=2.5, cjk_cps=4.5, latin_cps=15.0, pad=1.5)   # readcheck's defaults
 ONSCREEN_SKIPPED = []   # what reading index.html left out, said once on stdout
 NICE = (0.5, 1, 2, 5, 10, 15, 30, 60, 120, 300, 600, 900, 1800, 3600)
 NARR, NARR_EDGE, CAP, CAP_EDGE = (190, 204, 226), (120, 140, 180), (214, 224, 206), (140, 160, 130)
 SEC_A, SEC_B, SEC_EDGE = (216, 214, 206), (230, 228, 220), (170, 168, 160)
+AMBER_SOFT = (244, 224, 178)   # an on-screen text over the floor but under the pace's target
 
 def why_not(dur, need, rate, limit):
     """Why a text fails its rule, in a few words: rate and limit are None for the on-screen rule."""
     if rate is None:
-        return f"{dur:.1f} s < {need:.1f} s"
+        return f"{dur:.2f} s < {need:.2f} s"   # the floor is often near 1.5 s: tenths would read "1.2 s < 1.2 s"
     return f"{dur:.1f} s < {RC.SUB_FLOOR:g} s" if dur < RC.SUB_FLOOR - 1e-6 else f"{rate:.1f}/s > {limit:g}/s"
 
+def run_settings(project):
+    """readcheck's settings for this project: the BRIEF's Pace, else normal."""
+    pace, _, _ = RC.find_pace(project)
+    return RC.settings(pace or RC.DEFAULT_PACE)
+
 def captions(project, lang):
     p = project / "audio" / "captions.json"
     if not p.exists():
@@ -47,9 +52,10 @@ def captions(project, lang):
     langs = [lang] if lang else [k for k in ("zh", "en") if any(it.get(k) for it in items if isinstance(it, dict))] or [None]
     use = langs[0]   # one language per lane: zh when there is Chinese, --lang otherwise
     out = []
-    for label, t0, t1, text, _ in RC.pieces(items, use):
+    for label, t0, t1, text, _, _ in RC.pieces(items, use):
         dur = t1 - t0
-        ok, need, rate, limit = RC.verdict(text, dur, "subtitle", ONSCREEN)
+        state, need, _, rate, limit = RC.verdict(text, dur, "subtitle", RC.settings())
+        ok = state != "fail"
         why = "" if ok else why_not(dur, need, rate, limit)
         out.append({"id": label, "start": t0, "end": t1, "text": text, "ok": ok, "why": why})
     return out, p
@@ -69,13 +75,14 @@ def onscreen(project):
         items, stats = RC.export_html(html)
         note = RC.skipped_note(stats)
         if note: ONSCREEN_SKIPPED.append(note)
-        todo, src = [(it["id"], it["start"], it["end"], it["text"], it.get("read")) for it in items], html
+        todo, src = [(it["id"], it["start"], it["end"], it["text"], it.get("read"), it.get("pace")) for it in items], html
     clips = {str(it.get("id")): it["clip"] for it in items if isinstance(it, dict) and it.get("clip")}
-    out = []
-    for label, t0, t1, text, mode in todo:   # a text marked data-read="subtitle" is judged by the subtitle rule
-        ok, need, rate, limit = RC.verdict(text, t1 - t0, mode or "onscreen", ONSCREEN)
+    out, run = [], run_settings(project)
+    for label, t0, t1, text, mode, pace in todo:   # a text marked data-read="subtitle" is judged by the subtitle rule
+        state, need, _, rate, limit = RC.verdict(text, t1 - t0, mode or "onscreen", run, pace)
+        ok = state != "fail"
         why = "" if ok else why_not(t1 - t0, need, rate, limit)
-        out.append({"id": label, "start": t0, "end": t1, "text": text, "ok": ok, "why": why})
+        out.append({"id": label, "start": t0, "end": t1, "text": text, "ok": ok, "warn": state == "warn", "why": why})
         if label in clips: out[-1]["clip"] = clips[label]
     return out, src if out else None
 
@@ -249,8 +256,8 @@ def main():
             items, rows = (caps, cap_rows) if name == "captions" else (ons, on_rows)
             for it in sorted(items, key=lambda i: i["ok"], reverse=True):   # the failing ones last, on top
                 ry = y + 10 + 44 * rows[id(it)]
-                block(d, P, it["start"], it["end"], ry, ry + 38, V.RED_SOFT if not it["ok"] else CAP,
-                      V.RED if not it["ok"] else CAP_EDGE, it["text"], f_small if zoom else f_tiny, V.INK)
+                fill, edge = (V.RED_SOFT, V.RED) if not it["ok"] else (AMBER_SOFT, V.AMBER) if it.get("warn") else (CAP, CAP_EDGE)
+                block(d, P, it["start"], it["end"], ry, ry + 38, fill, edge, it["text"], f_small if zoom else f_tiny, V.INK)
         elif name == "music":
             for i, s in enumerate(bm.get("sections", [])):
                 block(d, P, float(s["start"]), float(s["end"]), y + 6, y + h - 34, SEC_A if i % 2 == 0 else SEC_B, SEC_EDGE,
@@ -309,6 +316,10 @@ def main():
         print(f"  note: {limit_src}")
     for note in ONSCREEN_SKIPPED:
         print(f"  on-screen text NOT checked: {note}")
+    warn = [o["id"] for o in ons if o.get("warn") and T0 - 1e-6 <= o["start"] <= T1 + 1e-6]
+    if warn:
+        print(f"  {len(warn)} on-screen text(s) over the floor but under the {run_settings(project).pace} target (amber, not an issue): "
+              + ", ".join(warn[:8]) + (" …" if len(warn) > 8 else ""))
     for t, msg, _ in vis:
         print(f"  {t:7.2f}s  {msg}")
     if not vis:
diff --git a/video-types/01-math-science-explainer.md b/video-types/01-math-science-explainer.md
index b8e6ae4..2b7cba4 100644
--- a/video-types/01-math-science-explainer.md
+++ b/video-types/01-math-science-explainer.md
@@ -65,7 +65,7 @@ Bind one color per math entity for the whole video; symbol and its geometry shar
 Open on the concrete puzzle with the core object on screen; say why it matters within 30s. Concrete example before the general rule.
 Geometry first, then the equation. Equations appear whole, dim to 30%, then light up and get colored term by term.
 Keep the parent diagram visible (dimmed) when zooming into details; dim old layers, never delete them mid-argument.
-After a question card, hold 2.5s. Each play() 1–3s, then a 0.5–2s hold. No bounce, glow, particles, or bullet-list ending.
+After a question card, hold 2–3s so the viewer can think (longer than the reading floor). Each play() 1–3s, then a 0.5–2s hold. No bounce, glow, particles, or bullet-list ending.
 Place objects only via a 6x6 anchor grid (A1–F6) in the animation area; print all bounding boxes and check overlaps before rendering.
 {Narrated: manim-voiceover, trigger visuals on bookmarks at {cue} words | Silent: timing comes from the storyboard reads; short on-screen labels carry the meaning}. Final render: -qh --fps 30.
 ```
diff --git a/video-types/02-knowledge-short.md b/video-types/02-knowledge-short.md
index ece8c72..55dd1fc 100644
--- a/video-types/02-knowledge-short.md
+++ b/video-types/02-knowledge-short.md
@@ -52,7 +52,7 @@
    - 选一种主风格【综合】：逐句（讲解的默认）；关键词强调（大多数知识片）；逐词高亮（只给高潮段，约 2% 的时长）；大字报（1–3 个词占满画面，只给钩子和转折，130–170 px）；对话条（问答）；双语（主语言大、副语言小，适合横屏，竖屏宽度不够）；
    - **术语卡**（可选）：默认不上专业词；人想保留真实的术语时（一位用户的原话："信道编码、调制 这几个基础的通信概念是可以保留的"），每到一个环节，先亮一张小卡写这一关的名字（"信道编码"），紧跟一句大白话字幕解释它（"再添上一些多出来的 0 和 1：路上丢几个，也补得回来"）。术语卡是独立的一层，字号按"在哪看"的次要文字下限，整层去掉也不影响字幕；英文缩写（QAM、LDPC）默认也不上屏，人要了再加。写在 SCRIPT 字幕表的"术语"列；
    - 静音可读，有声更好。信息流里静音观看是常态：Meta 测过，加字幕的视频广告平均多看 12% [S16a]；美国的调查里 69% 的人在公共场合静音看视频，英国 18–24 岁的人有 80% 看电视时部分或全部时间开着字幕【二手】[S17a][S17b]；
-   - 但无声观看更累：一项 161 人的眼动实验里，认知负荷明显升高、沉浸和愉悦下降，理解只略低（81% 对 78%）[S17c]；TikTok 也说自己是开声音的平台 [S2]。所以静音交付时同屏信息量减少，画面文字在 `playbook/03-motion-design.md` §2 的最少停留时间上再留 0.5–1 s（加多少没有数据【推测】）；
+   - 但无声观看更累：一项 161 人的眼动实验里，认知负荷明显升高、沉浸和愉悦下降，理解只略低（81% 对 78%）[S17c]；TikTok 也说自己是开声音的平台 [S2]。所以静音交付时同屏信息量减少，画面文字在 `playbook/03-motion-design.md` §2 的 Pace 目标上再留 0.5–1 s（或者 BRIEF 的 Pace 直接写 relaxed）（加多少没有数据【推测】）；
    - 竖屏短视频多数人静音看，旁白照常逐句上字幕。只有学习目标强、以有声观看为主的讲解（横屏的课程、B站长讲解），字幕才可以只留关键词和短句（Mayer 的冗余原则，见 `playbook/09-narrative.md` 第 4.2 节）【综合】；
    - 横屏字幕按 Netflix 的规范：中文每行 ≤ 16 字、≤ 9 字/秒、最多 2 行，不用逗号句号，用空格代替，问号、感叹号保留 [S18b]；英文每行 ≤ 42 字符、≤ 20 字符/秒、最多 2 行 [S18a]。
 6. **安全框**：关键内容放在 x 90–900、y 330–1520 之内，背景可以铺满。UI 遮挡多少像素，官方没有固定值：TikTok 只说遮挡随比例、文案长度和格式变化，给的是可下载的模板 [S3]；第三方给的 TikTok 下沿从 324 到 640 px 不等【二手】[S23]。有长文案、带话题标签的平台（抖音、小红书），把字幕带放在 y ≤ 1440 以内，发布前拿真机截图叠在联系表上校准【推测】。
diff --git a/video-types/09-editing-talking-head.md b/video-types/09-editing-talking-head.md
index b4786c8..77f18ea 100644
--- a/video-types/09-editing-talking-head.md
+++ b/video-types/09-editing-talking-head.md
@@ -37,13 +37,13 @@
 6. **吸附与渲染**：每个区间吸附到缺口里的能量谷，再落到帧格和过零点；留 handle；音频接缝交叉淡化 40 ms、画面硬切；一次编码。
 7. **验证**：逐接缝指标、重转写对账、按播放顺序连读一遍、接缝 strip。有问题只改受影响的区间重渲。
 8. **包装**：避脸字幕、必要的重构图、图解叠层（只用真实截图或录屏）、配乐和声音。
-9. **评审**：**打分层照旧：`TASTE_CHECKLIST` 的 8 项都 ≥ 8（硬规则 4；立意一项问的是这一版的剪辑思路：结构和取舍是不是在讲这段内容）**；再加两两对比，决定新版能不能取代当前版（`engines/editing.md`）。`standard` 做 1 轮，`studio` 至少 3 轮；再交人，关卡 ③。
+9. **评审**：**打分层照旧：`TASTE_CHECKLIST` 的 8 项都 ≥ 8（硬规则 4；立意一项问的是这一版的剪辑思路：结构和取舍是不是在讲这段内容）**；再加两两对比，决定新版能不能取代当前版（`engines/editing.md`）。`standard` 做 1 轮，`studio` 至少 3 轮、最多 10 轮（同一类问题最多改 5 次，小修只做局部复查，见 `TASTE_CHECKLIST` 打分层）；再交人，关卡 ③。
 10. **导出与交付**：`final.mp4`、`captions.srt`、`edl.json`；按需 FCPXML、OTIO、CapCut 或剪映包；素材台账和授权记录。
 
 **档位**：
 - `quick`（降档只能来自用户本人）：`transcript-cut.mjs` 自动粗剪加字幕，一张联系表，没有人工关卡；它按 ASR 的词边界切，这是本类唯一有意的例外（见"禁止"第一条），交付说明里写明接缝没测过。改动仍然先写成 `edl.json`，方便回溯。
 - `standard`：EDL 关卡、逐接缝指标、重转写对账、1 轮两两对比。
-- `studio`：再加重构图检查、至少 3 轮两两对比、导出到剪辑软件、人耳逐个接缝复听。
+- `studio`：再加重构图检查、至少 3 轮两两对比（最多 10 轮）、导出到剪辑软件、人耳逐个接缝复听。
 
 ## 审美要点