@dsh-gis/dsh-video-studio-skill 0.9.1 → 1.0.4

package/skills/video-studio/scripts/selfcheck.py

@@ -3,12 +3,12 @@
 
 跑法：python selfcheck.py [-v]
 
-检查的全是"曾经真的坏过"的点，不是泛泛的健康检查：
-  1  TTS 缓存必须校验文本（v0.1 只判文件存在 -> 改台词不生效）
-  2  sub_window 不能把长句字幕截断在 5.2s（v0.1 的硬钳）
-  3  loudness 必须能测到真峰（v0.1 的 ebur128 没开 peak -> 真峰门禁永不触发）
-  4  mux 默认不重编视频流（v0.1 二次编码）
-  5  FrameSink 尺寸不符必须报错（v0.1 静默 resize）
+检查的全是真实缺陷的回归点，不是泛泛的健康检查：
+  1  TTS 缓存必须校验文本（只判文件存在 -> 改台词不生效）
+  2  sub_window 不能把长句字幕截断在 5.2s（硬钳会让长句丢字）
+  3  loudness 必须能测到真峰（ebur128 没开 peak -> 真峰门禁永不触发）
+  4  mux 默认不重编视频流（二次编码会再压一遍画面）
+  5  FrameSink 尺寸不符必须报错（静默 resize 会让成片与构图不符）
   6  字形自查能识别缺字（msyhbd 缺 ✓ 等）
   7  ASS 头必须声明 PlayRes，且 Format/Dialogue 字段数一致
   8  时间轴第一段 start 严格为 0
@@ -16,48 +16,63 @@
  10  qa_report 能查出字幕条数不匹配
  11  尾静音裁剪
  12  mux 音轨 48kHz
- 13  v0.1 调用签名兼容
+ 13  旧调用签名兼容
  14  qa 帧率校验
- 15  （v0.3）立体声总线：channels=2 形状正确、声像能量守恒
- 16  （v0.3）cue_time 三种写法都解析成绝对秒
- 17  （v0.3）CueBus 落盘 -> 读回 -> schema 正确（含未知类型不崩）
- 18  （v0.3）duck 真的压低了配乐（且不改变无音效处的电平）
- 19  （v0.3）mix_film 峰值不越界、时长精确、旁白优先
- 20  （v0.3）sfxkit 可用时：配方确定性 + 别名表能从 sfxkit 反查
- 21  （v0.3）scorekit 可用时：同 seed bit-identical + 时长精确
- 22  （v0.3）webengine 可用时：页面契约齐全（window.renderFrame/getCues/ready）
- 23  （v0.3）qa_frames 可用时：能检出注入的单帧闪烁
- 24  （v0.4.0）配乐来源：music.mode=off 不读上一轮 work/music.wav（模式判定回归）
-  25  （v0.5.0）风格层：8 套主题全部过对比度门禁，8 类题材能分出 >=6 种风格
-  26  （v0.5.0）legacy 兼容：没写 style 字段必须精确落回 Dm/120/seed7/单声线
-  27  （v0.5.0）内容指纹：同剧本稳定、改标点不换风格、换题材才换
-  28  （v0.5.0）声线计划：4 句样片 >=2 把声音，legacy 仍是单声线
-  29  （v0.5.0）字体族与主题字幕：换族换缓存键，浅色主题不画黑背板
-  30  （v0.6.0）门禁账本与签核：pass/fail/skipped 三档不许混，签核必须绑内容指纹
-  31  （v0.6.0）阶段新鲜度：改了输入必须报"过时"，不许用旧产物静默出片
-  32  （v0.6.0）并行渲染主题序列化：JSON 往返后重解风格必须回到 tuple
-  33  （v0.7.0）音效跨片可区分：内容派生 seed 让跨片不同、legacy 逐样本不变
-  34  （v0.7.0）配乐/音效片内分离：duck 默认加深，配乐给音效让位
-  35  （v0.7.1）旁白优先：人声出现时背景必须再压、间隙恢复、人声电平不动
-  36  （v0.7.1）旁白优先默认值：配乐 -12 dB 基线 + 旁白侧链 6 dB（读 st_audio 源码）
-  37  （v0.7.1）旁白清晰度 SNR 兜底：背景天然太响时自动补压到 >=12 dB
-  38  （v0.7.1）无旁白时混音不受影响（voice_env/guard 不得空转改电平）
-  39  （v0.7.2）音频边界：极短旁白不崩、NaN/Inf 拒绝写盘、负起点与 seg=0 有守卫
-  40  （v0.7.2）QC 报告落点只有一个来源（--out 的目录，不许 accept 另算一套）
-  41  （v0.7.2）空门禁账本不许写成"通过"（没记录 != 通过）
-  42  （v0.7.2）单阶段产物归属：不许把别的 stage 写的文件算成自己的（假 stale）
-  43  （v0.7.2）theme_overrides 必须参与主题体检（否则能造出"看不清"的成片）
-  44  （v0.8.0）词级时间戳：规整（单调/裁剪/偏移）与 cue 词锚点解析
-  45  （v0.8.0）画幅规划：只允许 16:9 横屏下采样，竖屏/上采样/非法 fps 必须拒绝
-  46  （v0.8.0）金帧确定性：同一帧号两次渲染必须逐像素一致
-  47  （v0.8.0）依赖漂移体检：numpy/Pillow 主版本 + edge-tts 仍暴露 boundary 参数
-  48  （v0.8.0）批量清单解析：两种写法都认、上限卡死、坏条目在开跑前报错
-  49  （v0.8.0）TTS 后端可替换：注册/注销/未知后端的接口契约
-  50  （v0.8.0）web 风格载荷：style=None 时不得注入 __STYLE__（legacy 必须回落）
-  51  （v0.8.0）金帧回归：与 assets/golden_frames.json 的像素基线比对
+ 15  立体声总线：channels=2 形状正确、声像能量守恒
+ 16  cue_time 三种写法都解析成绝对秒
+ 17  CueBus 落盘 -> 读回 -> schema 正确（含未知类型不崩）
+ 18  duck 真的压低了配乐（且不改变无音效处的电平）
+ 19  mix_film 峰值不越界、时长精确、旁白优先
+ 20  sfxkit 可用时：配方确定性 + 别名表能从 sfxkit 反查
+ 21  scorekit 可用时：同 seed bit-identical + 时长精确
+ 22  webengine 可用时：页面契约齐全（window.renderFrame/getCues/ready）
+ 23  qa_frames 可用时：能检出注入的单帧闪烁
+ 24  配乐来源：music.mode=off 不读上一轮 work/music.wav（模式判定回归）
+  25  风格层：每套采样主题全部过对比度门禁，8 类题材能分出 >=6 种风格
+  26  legacy 已移除：不写 style 必须**报错并给迁移指引**（守的是"旧外观路径真的
+      没了"，而不是"精确落回某套老默认值"）
+  27  内容指纹：同剧本稳定、改标点不换风格、换题材才换
+  28  声线计划：4 句样片 >=2 把声音，legacy 仍是单声线
+  29  字体族与主题字幕：换族换缓存键，浅色主题不画黑背板
+  30  门禁账本与签核：pass/fail/skipped 三档不许混，签核必须绑内容指纹
+  31  阶段新鲜度：改了输入必须报"过时"，不许用旧产物静默出片
+  32  并行渲染主题序列化：JSON 往返后重解风格必须回到 tuple
+  33  音效跨片可区分：内容派生 seed 让跨片不同、legacy 逐样本不变
+  34  配乐/音效片内分离：duck 默认加深，配乐给音效让位
+  35  旁白优先：人声出现时背景必须再压、间隙恢复、人声电平不动
+  36  旁白优先默认值：配乐 -12 dB 基线 + 旁白侧链 6 dB（读 st_audio 源码）
+  37  旁白清晰度 SNR 兜底：背景天然太响时自动补压到 >=12 dB
+  38  无旁白时混音不受影响（voice_env/guard 不得空转改电平）
+  39  音频边界：极短旁白不崩、NaN/Inf 拒绝写盘、负起点与 seg=0 有守卫
+  40  QC 报告落点只有一个来源（--out 的目录，不许 accept 另算一套）
+  41  空门禁账本不许写成"通过"（没记录 != 通过）
+  42  单阶段产物归属：不许把别的 stage 写的文件算成自己的（假 stale）
+  43  theme_overrides 必须参与主题体检（否则能造出"看不清"的成片）
+  44  词级时间戳：规整（单调/裁剪/偏移）与 cue 词锚点解析
+  45  画幅规划：只允许 16:9 横屏下采样，竖屏/上采样/非法 fps 必须拒绝
+  46  金帧确定性：同一帧号两次渲染必须逐像素一致
+  47  依赖漂移体检：numpy/Pillow 主版本 + edge-tts 仍暴露 boundary 参数
+  48  批量清单解析：两种写法都认、上限卡死、坏条目在开跑前报错
+  49  TTS 后端可替换：注册/注销/未知后端的接口契约
+  50  web 风格载荷：style=None 时不得注入 __STYLE__（legacy 必须回落）
+  51  金帧回归：与 assets/golden_frames.json 的像素基线比对
+  52  场景语法：10 类构图分流、选型确定性、段长降级门
+  53  视觉语言包：8 套结构签名齐全、过体检、彼此不是同一套
+  54  场景类型单真值：grammar / filmcheck / scenes / schema 四处集合相等
+  55  剪影可区分（G13）：8 套风格两两之间构图骨架必须能区分
+  56  设计 DSL：采样->校验->转计划全通；缺必填块必须报错（fail-closed）；
+      同 brief 两次采样一致；两两至少 2 维不同（"伪多方案"门禁）
+  57  零模板：仓库里不许存在 presets/ 与 presetkit.py；现场采样必须确定性、
+      且换 brief 必须换结果（否则就是还在套模板）
+  58  提案闸：absent / draft / broken 三档判定正确（confirmed 才放行出片）
+  59  逐 stage 可单独跑：render 里每处 resolve_style 都必须拿得到 work
+      （只跑 --stage frames / --stage sfx 时缺参数会报"找不到设计"，all 被缓存掩盖）
+  60  brief 里的要求真的生效：自然语言要解析成 must_have/avoid，
+      配色约束按色相窗口生效（早先整句被塞进 topic，"深蓝"采出来是橙色）
 
 说明：本文件里 CASES 的**实际条数**是唯一真理，上面的编号表要与它同步。
-v0.8.0 之前这张表停在 43 条而 CASES 已经有 51 条，属于"自检清单自己没被自检"。
+这张表落后过两次：停在 43 条而 CASES 已有 51 条、停在 51 条而 CASES 已有 58 条。
+改 CASES 时请同批改这张表，别让它再次落后。
 """
 import argparse
 import io
@@ -104,11 +119,37 @@ def run(name, fn):
     except AssertionError as e:
         RESULTS.append(("FAIL", name, str(e)))
         print("  FAIL %s  -> %s" % (name, e))
+    except SystemExit as e:
+        # 被调代码用 SystemExit 报"用法错误"（例如 resolve_style 要求先提案）。
+        # 必须记 FAIL 而不是让自检直接退出 —— 早先 selfcheck 会在这里**静默中止**，
+        # 后面的用例一条都不跑，输出留在半截，很容易被当成"还在跑"。
+        RESULTS.append(("FAIL", name, "SystemExit: %s" % (e.code if str(e.code) != "None" else e)))
+        print("  FAIL %s  -> SystemExit: %s" % (name, e))
     except Exception as e:                      # noqa: BLE001
         RESULTS.append(("FAIL", name, "%s: %s" % (type(e).__name__, e)))
         print("  FAIL %s  -> %s: %s" % (name, type(e).__name__, e))
 
 
+# 自检专用：造一份 design 计划。
+# 删掉内置风格表后，"要一份 plan"这件事只能靠现场采样 + 转计划；
+# 每个用例各写一遍既啰嗦又容易漂移，于是收到这里。
+# 固定 seed 保证自检自身可复现（自检必须可复现，否则 CI 抖起来没法查）。
+_PLAN_CACHE = {}
+
+
+def _design_plan(topic="selfcheck 样例", seed=20260101):
+    key = (topic, seed)
+    if key not in _PLAN_CACHE:
+        import designkit as DK
+        d = DK.sample_designs({"topic": topic}, n=1, seed=seed)[0]
+        _PLAN_CACHE[key] = (d, DK.design_to_plan(d))
+    return _PLAN_CACHE[key]
+
+
+def _sample_design(topic="selfcheck 样例", seed=20260101):
+    return _design_plan(topic, seed)[0]
+
+
 def _tone_wav(path, seconds=1.0, freq=440.0):
     import numpy as np
     n = int(seconds * K.SR)
@@ -297,7 +338,7 @@ def t_mux_48k():
 
 
 def t_compat():
-    """v0.1 的调用签名必须还能用（升级不能把老项目直接炸掉）。"""
+    """旧调用签名必须还能用（升级不能把老项目直接炸掉）。"""
     a = K.tone(440, 0.2, kind="sine", harmonics=(1.0, 0.5))
     b = K.noise_burst(0.2, amp=0.1, lo=0.02, hi=0.35, decay=6.0, seed=7)
     assert len(a) > 0 and len(b) > 0, "兼容签名返回空"
@@ -309,7 +350,7 @@ def t_compat():
 
 
 def t_fps_check():
-    """qa_report 必须能查出帧率不符（v0.2 之前只查宽高）。"""
+    """qa_report 必须能查出帧率不符（只查宽高会漏掉帧率写错）。"""
     with tempfile.TemporaryDirectory() as d:
         v = os.path.join(d, "v25.mp4")
         r = subprocess.run([K.FFMPEG, "-y", "-v", "error", "-f", "lavfi",
@@ -322,7 +363,7 @@ def t_fps_check():
     return "25fps 被检出"
 
 
-# ---------------------------------------------------------------- v0.3.0 新增
+# ---------------------------------------------------------------- 立体声 / 配乐 / 音效
 def t_stereo_bus():
     """立体声总线：形状、声像、单声道来源自动展开。"""
     import numpy as np
@@ -411,9 +452,9 @@ def t_mix_film():
 
 
 def t_music_plan():
-    """配乐来源判定：music.mode=off 不得读上一轮的 work/music.wav（v0.3.0 的回归）。
+    """配乐来源判定：music.mode=off 不得读上一轮的 work/music.wav。
 
-    背景：v0.3.0 的 st_audio 无条件读 work/music.wav，于是用户把 music.mode 改成 off
+    背景：st_audio 若无条件读 work/music.wav，用户把 music.mode 改成 off
     之后，上一轮跑出来的旧配乐仍被混进成片（文档写的是 off = 不要配乐）。
     这里既测判定函数，也真的跑一次 st_audio 看输出电平。
     """
@@ -428,7 +469,7 @@ def t_music_plan():
     assert K.music_plan({"music": {"mode": "weird"}})[0] == "unknown-mode", "未知 mode 没报错（会静默当 auto）"
     assert K.music_plan({}, True)[0] == "file", "缺省时外部 music.wav 兼容链断了"
     assert K.music_plan({}, False)[0] == "none", "缺省且什么都没有时应判 none"
-    assert K.music_plan({"music": {"chords": [[220.0, 261.6]]}}, False)[0] == "bed", "v0.2 和弦床兼容链断了"
+    assert K.music_plan({"music": {"chords": [[220.0, 261.6]]}}, False)[0] == "bed", "和弦床兼容链断了"
 
     # 2) 端到端：st_audio 在 mode=off 下不得混入 work/music.wav
     try:
@@ -451,13 +492,19 @@ def t_music_plan():
         K.wav_write(os.path.join(work, "music.wav"), np.stack([loud, loud], axis=1))
         buf = io.StringIO()
         with redirect_stdout(buf):
-            off_out = render.st_audio(tl, work, {"music": {"mode": "off"}})
+            # D3 之后没有 design/style 的剧本会被拒（不再静默落 legacy），
+            # 这条用例测的是"off 不读旧配乐"，与设计无关，显式给一个风格即可。
+            # D3 之后没有 design/style 的剧本会被拒（不再静默落 legacy），
+            # 这条用例测的是"off 不读旧配乐"，与设计无关，给一份现场设计即可。
+            _d, _plan = _design_plan("配乐来源判定")
+            _script23 = {"title": "配乐来源", "_style": _plan}
+            off_out = render.st_audio(tl, work, dict(_script23, music={"mode": "off"}))
             off_peak = float(np.max(np.abs(K.wav_read(off_out)[0])))
-            file_out = render.st_audio(tl, work, {"music": {"mode": "file"}})
+            file_out = render.st_audio(tl, work, dict(_script23, music={"mode": "file"}))
             file_peak = float(np.max(np.abs(K.wav_read(file_out)[0])))
         assert "music.mode=off" in buf.getvalue(), "off 没有打印说明（静默跳过也不行）"
         assert off_peak < 0.01, "music.mode=off 仍把旧 music.wav 混进来了（峰值 %.3f）" % off_peak
-        # v0.7.1：断言改成"相对 off 明显变大"而不是绝对 0.3——
+        # 断言用"相对 off 明显变大"而不是绝对 0.3——
         # 配乐基线降到 -12 dB（旁白优先）后，0.8 幅度的外部配乐混出来约 0.2；
         # 绝对阈值会把"旁白优先调好了"判成"没读到外部配乐"，这类断言会被调参牵着走。
         assert file_peak > 0.1 and file_peak > off_peak * 3.0, (
@@ -552,79 +599,89 @@ def t_qa_frames():
 
 
 def t_style_kits():
-    """25 风格层：8 套主题过对比度门禁 + 自动选风格能把 8 类题材分开。"""
+    """25 连续配色空间：现场采样的每一套都必须过对比度门禁，
+    且色相真的分散——这条是"没有模板"的硬证据。
+
+    旧断言是"8 套内置主题全部过 lint + 自动选风格能分出 >=6 种"。模板删掉后那个断言
+    失去对象，于是换成更强的：**连续空间采样 12 次，全部可读 + 色相覆盖 >= 180°**。
+    只测"能采出来"不够 —— 全落在同一色相也能过，所以必须夹一条分布断言。
+    """
+    import designkit as DK
     import stylekit as ST
-    bad = ST.lint_all()
-    assert not bad, "内置主题没过对比度门禁: %s" % bad
-    topics = {
-        "tech": "AI 算法 模型 数据 架构 开源 编程 大模型 代码 系统",
-        "report": "报告 复盘 年度 总结 研究 分析 调研 白皮书 趋势 发布",
-        "craft": "手工 自然 历史 传统 木 田野 匠 古 茶 手艺 山河",
-        "launch": "活动 上新 招募 挑战 年轻 潮流 种草 福利 开箱 限量",
-        "truth": "观点 为什么 本质 真相 极简 反思 边界 定义 取舍",
-        "story": "故事 记忆 城市 深夜 旅行 纪实 情绪 时代 变迁 命运",
-        "night": "深夜 学习 效率 专注 写作 整理 笔记 书 日常 房间",
-        "epic": "史诗 爆发 冲击 巅峰 决战 荣耀 震撼 传奇 极限 突破",
-    }
-    got = {}
-    for key, text in topics.items():
-        s = {"title": text, "style": "auto",
-             "lines": [{"id": "l01", "kind": "hook", "text": text},
-                       {"id": "l02", "kind": "body", "text": text}]}
-        got[key] = ST.resolve_script_style(s)["style"]
-    assert len(set(got.values())) >= 6, "8 类题材只分出 %d 套风格: %s" % (len(set(got.values())), got)
-    return "%d 套主题 + %d 类题材 -> %d 种风格" % (len(ST.STYLE_IDS), len(topics), len(set(got.values())))
+    designs = DK.sample_designs({"topic": "配色空间校验"}, n=12, seed=20260101)
+    assert len(designs) == 12, "采样返回 %d 套（要 12）" % len(designs)
+    hues, fails = [], []
+    for d in designs:
+        plan = DK.design_to_plan(d)
+        bad = ST.theme_lint(plan["theme"])
+        if bad:
+            fails.append("%s: %s" % (d["label"], bad[0][:50]))
+        h, _s, _v = ST.rgb_to_hsv(plan["theme"]["bg"])
+        hues.append(h)
+    assert not fails, "有设计过不了对比度门禁：%s" % "；".join(fails[:3])
+    span = max(hues) - min(hues)
+    if span < 180.0:                        # 跨 0° 的情况：取补集
+        span = 360.0 - span
+    assert span >= 180.0, ("12 套设计的底色谱相只覆盖 %.0f°（应 >=180°）——"
+                           "说明配色并没有真的在连续空间里散开" % span)
+    # 配色必须是**连续**的，不是一份清单：断言"色相是连续量"而不是"落在 8 个点之一"。
+    # 做法：取 12 套的色相，检查它们不是某个固定集合的子集（容差 1°）。
+    # 早先这里断言的是 `len(PALETTE_FAMILIES) == len(_LEGACY_FAMILY_ANCHOR)` ——
+    # 而那两个名字是**同一个对象**，长度当然永远相等，等于什么也没验。
+    assert not DK.PALETTE_FAMILIES, "PALETTE_FAMILIES 必须为空（有内容=偷偷恢复了外观清单）"
+    rounded = sorted({round(h) for h in hues})
+    spread = len(rounded) / float(len(hues))
+    assert spread >= 0.8, ("12 套配色的色相只有 %d 个不同取值（%s）——"
+                           "说明配色退化成了一份离散清单" % (len(rounded), rounded))
+    return "12 套现场配色全部过 lint；色相覆盖 %.0f°；%d/12 个不同色相" % (
+        span, len(rounded))
 
 
 def t_style_legacy():
-    """26 legacy 兼容：没写 style 字段必须精确落回 v0.4 的配乐/旁白参数。"""
+    """26 legacy 已移除：不写 style 必须报错并给出迁移指引，而不是静默落老外观。
+
+    这条盯的是"不写外观配置照样能出片"这条老思路真的没了：legacy 路径整个删掉，
+    因为它是同质化的另一半根因（不写 style = 全片一套固定外观 + 120BPM/Dm）。
+    断言分成两半：① 不给设计时必须**报错**且错误文本指得出下一步；
+    ② 显式给 style 也不可用（内置风格表已删，任何 style id 都必须落空报错）。
+    """
     import stylekit as ST
     s = {"title": "旧项目", "lines": [{"id": "a", "kind": "body", "text": "x"}]}
-    p = ST.resolve_script_style(s)
-    assert p["legacy"] is True, "没有 style 字段却没走 legacy"
-    assert p["music"]["bpm"] == 120.0, "legacy BPM 应为 120，收到 %r" % (p["music"]["bpm"],)
-    assert p["music"]["key"] == "Dm", "legacy 调性应为 Dm，收到 %r" % (p["music"]["key"],)
-    assert p["music"]["seed_effective"] == 7, "legacy seed 应为 7（不做内容派生）"
-    assert p["music"]["seed_from_content"] is False
-    assert p["voice"]["map"] == {}, "legacy 不该有声线映射"
-    assert p["voice"]["policy"]["jitter"] == 0.0 and p["voice"]["policy"]["auto"] is False
-    # legacy 的节奏必须等于 render.py v0.4 的函数默认值，否则"没写 lead 的老剧本"会变节奏
-    assert (p["pacing"]["lead"], p["pacing"]["tail"], p["pacing"]["min_dur"]) == (0.55, 0.85, 3.0), p["pacing"]
-    # 显式 "legacy" 也必须是同一档
-    s2 = dict(s, style="legacy")
-    assert ST.resolve_script_style(s2)["legacy"] is True
-    # 显式风格则必须真的换掉三件套
+    # ① 不给设计：必须报错，且错误文本指得出下一步
+    try:
+        ST.resolve_script_style(s)
+    except (ValueError, KeyError, SystemExit) as e:
+        msg = str(getattr(e, "code", None) or e)
+        assert "propose.py" in msg, "报错必须给出迁移指引（要提到 propose.py），实际：%r" % msg[:120]
+        assert "design" in msg.lower(), "报错要说清主路径是 design.json，实际：%r" % msg[:120]
+    else:
+        raise AssertionError("没有 style/design 却没报错：legacy 路径没有真的移除")
+    # ② 显式 style 也不可用——内置风格表整个删了，连带 STYLES 一起没了，
+    #    任何 style id 都必须落空并报错（否则就是"模板还在"）。
     s3 = dict(s, style="cinema")
-    p3 = ST.resolve_script_style(s3)
-    assert p3["legacy"] is False and p3["music"]["bpm"] in ST.STYLES["cinema"]["music"]["bpm_ladder"]
-    assert p3["music"]["key"] in ST.STYLES["cinema"]["music"]["keys"]
-    return "bpm=%g key=%s seed=%d / cinema: bpm=%g key=%s" % (
-        p["music"]["bpm"], p["music"]["key"], p["music"]["seed_effective"],
-        p3["music"]["bpm"], p3["music"]["key"])
+    try:
+        ST.resolve_script_style(s3)
+    except (ValueError, KeyError, SystemExit) as e:
+        msg = str(getattr(e, "code", None) or e)
+        assert "模板" in msg or "design" in msg.lower() or "propose" in msg,             "显式 style 报错也该给指引，实际：%r" % msg[:120]
+    else:
+        raise AssertionError("显式 style='cinema' 竟然还能解析出计划：内置风格表没删干净")
+    assert ST.STYLE_IDS == () and not ST.STYLES and not ST.THEMES,         "内置风格/主题表必须为空，实际 STYLE_IDS=%r STYLES=%d THEMES=%d" % (
+            ST.STYLE_IDS, len(ST.STYLES), len(ST.THEMES))
+    return "无设计必报错并给迁移指引 / 显式 style 也被拒绝 / 三张模板表为空"
 
 
 def t_style_determinism():
     """27 指纹确定性：同剧本同结果；改错别字不换风格；改题材才换。"""
-    import stylekit as ST
-    base = {"title": "AI 大模型的三年", "style": "auto",
-            "lines": [{"id": "l01", "kind": "hook", "text": "大模型改变了什么"},
-                      {"id": "l02", "kind": "body", "text": "算法和数据的规模一起上去了"}]}
-    a = ST.resolve_script_style(base)
-    b = ST.resolve_script_style(json.loads(json.dumps(base)))
-    assert json.dumps(a, sort_keys=True, default=str) == json.dumps(b, sort_keys=True, default=str), \
-        "同一剧本两次解析结果不同（不确定性）"
-    typo = json.loads(json.dumps(base))
-    typo["lines"][1]["text"] += "。"
-    c = ST.resolve_script_style(typo)
-    assert c["style"] == a["style"], "改一个标点就换了风格: %s -> %s" % (a["style"], c["style"])
-    assert c["music"]["bpm"] == a["music"]["bpm"], "改一个标点就换了 BPM"
-    assert c["fingerprint"]["full"] != a["fingerprint"]["full"], "full 指纹没变（内容派生失效）"
-    other = {"title": "深夜学习指南", "style": "auto",
-             "lines": [{"id": "l01", "kind": "hook", "text": "为什么深夜反而能专注"},
-                       {"id": "l02", "kind": "body", "text": "整理笔记，写作，阅读都更安静"}]}
-    d = ST.resolve_script_style(other)
-    assert d["style"] != a["style"], "换了一部片风格却相同: %s" % d["style"]
-    return "%s -> %s（同一剧本稳定），换片 -> %s" % (a["style"], c["style"], d["style"])
+    import designkit as DK
+    # 没有"剧本 -> 自动选风格"了，这里验证"设计采样"的确定性与区分度。
+    # 固定 seed 才谈确定性：默认不给 seed 时每次都要不同（那是 56/57 条在守的事）。
+    a = DK.sample_designs({"topic": "AI 大模型的三年"}, n=1, seed=11)[0]
+    b = DK.sample_designs({"topic": "AI 大模型的三年"}, n=1, seed=11)[0]
+    assert DK.design_fingerprint(a) == DK.design_fingerprint(b), "同 seed 同 brief 采样不一致"
+    assert DK.design_fingerprint(a) != DK.design_fingerprint(
+        DK.sample_designs({"topic": "手工木作"}, n=1, seed=11)[0]), "换了题材设计却没变"
+    return "同 seed 可复现 + 换题材必变"
 
 
 def t_voice_plan():
@@ -633,44 +690,48 @@ def t_voice_plan():
         import voicekit as VK
     except Exception:                                       # noqa: BLE001
         return "skip"
-    import stylekit as ST
-    s = {"title": "AI 大模型", "style": "auto",
+    import designkit as DK
+    s = {"title": "AI 大模型",
          "lines": [{"id": "l01", "kind": "hook", "text": "大模型改变了什么"},
                    {"id": "l02", "kind": "body", "text": "算法和数据的规模一起上去了"},
                    {"id": "l03", "kind": "quote", "text": "他说：这不可能"},
                    {"id": "l04", "kind": "outro", "text": "它已经在我们身边了"}]}
-    plan = ST.resolve_script_style(s)
+    # 声线计划同样只能从设计来（模板表已删）
+    plan = DK.design_to_plan(DK.sample_designs({"topic": "AI 大模型"}, n=1, seed=7)[0])
     vp = VK.voice_plan(s, plan)
     assert len(vp) == 4, "计划行数应为 4，收到 %d" % len(vp)
     assert json.dumps(vp, sort_keys=True, default=str) == json.dumps(
         VK.voice_plan(s, plan), sort_keys=True, default=str), "voice_plan 不确定"
-    personas = {r["persona"] for r in vp}
-    assert len(personas) >= 2, "4 句样片只用了一个声线: %s" % personas
+    # persona 身份表已删，声音身份的唯一表示是 edge voice id。
+    # 这里断言"至少 2 个不同的 voice id"——语义与旧 persona 表一致，字段换了。
+    voices = {r["voice"] for r in vp}
+    assert len(voices) >= 2, "4 句样片只用了一个声线: %s" % voices
     tones = {r["tone"] for r in vp}
     assert len(tones) >= 2, "语气档没有变化: %s" % tones
     for r in vp:
         for fld in ("voice", "rate", "pitch", "volume", "lead", "tail"):
             assert r.get(fld) not in (None, ""), "计划行缺 %s: %r" % (fld, r.get("id"))
-    # legacy：单声线、body 语气、无抖动
-    leg = {"title": "旧项目", "lines": [{"id": "a", "kind": "body", "text": "x"}]}
-    lp = ST.resolve_script_style(leg)
-    lvp = VK.voice_plan(leg, lp)
-    assert len({r["voice"] for r in lvp}) == 1, "legacy 出现多声线"
-    assert all(r["tone"] == "body" for r in lvp), "legacy 不该换语气档"
-    return "%d 句 / %d 把声音 / %d 档语气" % (len(vp), len(personas), len(tones))
+    # 单句片：同样走 design（不再有 style="mono" 这种内置风格可选）
+    one = {"title": "单句片",
+           "lines": [{"id": "a", "kind": "body", "text": "一句话"}]}
+    op = DK.design_to_plan(DK.sample_designs({"topic": "单句片"}, n=1, seed=3)[0])
+    ovp = VK.voice_plan(one, op)
+    assert len(ovp) == 1, "单句片应只给一行计划，收到 %d" % len(ovp)
+    assert ovp[0]["voice"].endswith("Neural"), "声线应是 edge voice id：%r" % (ovp[0]["voice"],)
+    return "%d 句 / %d 把声音 / %d 档语气" % (len(vp), len(voices), len(tones))
 
 
 def t_font_family():
     """29 字体族 + 字幕主题：换族必须换缓存键，主题字幕不能是黑底白字。
 
     **别把"系统装了几族字体"当成产品缺陷**：CI 的 ubuntu 只装 fonts-noto-cjk，
-    四个族全回退到同一个 NotoSansCJK，宽度必然一样。v0.5.0 的第一版就在这里误报——
-    断言写成"宽度必须不同"，于是 Linux CI 红、Windows 绿。
+    四个族全回退到同一个 NotoSansCJK，宽度必然一样。断言若写成"宽度必须不同"就会误报——
+    Linux CI 红、Windows 绿。
     真正要保证的是**机制**：缓存按 family 分键（换族不会串味）；
     宽度差异只在"系统确实解析出不同字体文件"时才有意义，单族系统跳过并说明。
     """
     fams = list(getattr(K, "FAMILY_IDS", ()))
-    assert fams, "filmkit 没有 FONT_FAMILIES（v0.5 字体族没生效）"
+    assert fams, "filmkit 没有 FONT_FAMILIES（字体族没生效）"
     resolved = {}
     for fam in fams:
         f = K.font(40, "bold", fam)
@@ -704,11 +765,13 @@ def t_font_family():
     assert K.wrap_cn_cached("旧调用", 40, 500) is not None
     # 字幕主题：浅色主题不该画黑背板
     from PIL import Image
-    try:
-        import stylekit as ST
-        th = ST.THEMES["magazine"]
-    except Exception:                                       # noqa: BLE001
-        th = None
+    # 没有内置主题可借（THEMES 已清空），手写一份浅色主题。
+    # 这条断言测的是 draw_subtitle 的"浅底不画黑背板"逻辑，与主题从哪来无关。
+    th = {"bg": (247, 244, 238), "bg2": (233, 228, 218), "surface": (255, 255, 255),
+          "ink": (26, 24, 22), "muted": (110, 104, 96), "dim": (150, 146, 140),
+          "accent": (198, 96, 40), "accent2": (52, 96, 160),
+          "good": (46, 150, 92), "bad": (200, 60, 60), "rule": (208, 202, 192),
+          "id": "selfcheck-light", "label": "浅色测试"}
     if th is not None:
         img = Image.new("RGB", (K.W, K.H), th["bg"])
         K.draw_subtitle(img, "浅色主题字幕", theme=th)
@@ -722,7 +785,7 @@ def t_font_family():
 def t_gates():
     """30 门禁账本 / 签核 / QC 报告：三档状态必须能区分"没查"和"通过"。
 
-    这一条防的是 v0.6.0 自己最容易犯的错——把 skipped 混进 pass。
+    这一条防的是最容易犯的错——把 skipped 混进 pass。
     用户看到的"质检通过"必须能区分"我查了 9 项"和"我只查了 3 项"：
     前者是真知情，后者是假安全感。顺带验签核绑内容指纹：改了剧本旧签核必须失效。
     """
@@ -770,7 +833,7 @@ def t_gates():
 def t_stagewatch():
     """31 阶段新鲜度：改上游 -> 下游必须报过时；首跑不刷噪声；产物丢失要报。
 
-    这一条防的是 v0.6.0 前的老问题：frames 有分块指纹，其余 stage 全是裸奔
+    这一条防的是：frames 有分块指纹，其余 stage 全是裸奔
     （改 style 后 audio 仍读旧 music.wav、改 hold 后 frames 仍用旧 cues.json，都不报错）。
     """
     import tempfile
@@ -806,7 +869,7 @@ def t_stagewatch():
     errs_strict, _ = SW.report(w, ["tts"], strict=True, write=lambda lv, m: None)
     assert errs_strict, "--strict-stale 没有让过时变成失败"
     # **源头输入**（剧本 / scenes.py）改了但没重跑 -> 必须报 source-changed。
-    # 这条是 v0.6.0 补的洞：早期只跟踪 stage 之间的产物，"改了台词没重跑 tts" 查不出来，
+    # 这条守的是：只跟踪 stage 之间的产物时，"改了台词没重跑 tts" 查不出来，
     # 而那正是最需要报警的场景（旧 tts 配新剧本 = 配音字幕全错位）。
     w2 = tempfile.mkdtemp(prefix="sc_sw2_")
     film = os.path.join(w2, "film.json")
@@ -822,7 +885,7 @@ def t_stagewatch():
     open(film, "w", encoding="utf-8").write("{\"title\":\"b\"}")   # 改剧本
     issues = [i for r in SW.explain(w2, ["tts"], src) for i in r["issues"]]
     assert any(i["kind"] == "source-changed" for i in issues), (
-        "改了剧本却没报过时（这正是 v0.6.0 要堵的洞）：%s" % issues)
+        "改了剧本却没报过时（这正是阶段新鲜度要堵的洞）：%s" % issues)
     assert any("film.json" in i["reason"] for i in issues), issues
     # 坏 manifest 不许崩（用户手改坏一个 json 不该让整片跑不动）
     open(os.path.join(w, "manifest.json"), "w", encoding="utf-8").write("{broken")
@@ -831,7 +894,7 @@ def t_stagewatch():
 
 
 def t_parallel_frames():
-    """32 --jobs >1 的并行路径能真的跑（v0.6.0 修的 pre-existing bug）。
+    """32 --jobs >1 的并行路径能真的跑（pre-existing bug 的回归）。
 
     bug 形状：worker 从 _script_snapshot.json 读剧本，JSON 把主题色元组变成 list，
     scenes._bg() 拿它当缓存键 -> TypeError: unhashable type: "list"，
@@ -841,8 +904,9 @@ def t_parallel_frames():
     """
     import json as _json
     import tempfile
-    import stylekit as ST
-    th = dict(ST.THEMES["tech-deep"])
+    # 没有内置主题可借，用现场设计的主题（颜色同样是 (r,g,b) 元组）
+    _d, _plan0 = _design_plan("并行渲染主题序列化")
+    th = dict(_plan0["theme"])
     # ① 防御层：scenes._hashable 把 list 冻结成 tuple
     scenes = _load_scenes_mod()
     if scenes is not None and hasattr(scenes, "_hashable"):
@@ -854,18 +918,29 @@ def t_parallel_frames():
     assert isinstance(round_trip["bg"], list), "前提变了：JSON 居然保住了 tuple"
     w = tempfile.mkdtemp(prefix="sc_par_")
     snap = os.path.join(w, "snap.json")
-    script = {"title": "t", "style": "tech-deep", "lines": [{"text": "x"}]}
-    script["_style"] = ST.resolve_script_style(script)
+    script = {"title": "t", "lines": [{"text": "x"}]}
+    script["_style"] = _plan0
     with open(snap, "w", encoding="utf-8") as fh:
         _json.dump(script, fh, ensure_ascii=False)
     back = _json.load(open(snap, encoding="utf-8"))
     assert isinstance(back["_style"]["theme"]["bg"], list), "前提变了"
-    # 重解风格（render.resolve_style 的纯函数部分）：必须回到 tuple
-    again = ST.resolve_script_style(back)
-    assert isinstance(again["theme"]["bg"], tuple), (
-        "--jobs >1 时主题色仍是 list，_bg() 会 TypeError（这正是被修的 bug）：%r"
-        % (again["theme"]["bg"],))
-    return "主题标量可哈希 + 反序列化后重解回 tuple"
+    # 子进程路径（worker 必须从 work/design.json 重解设计，而不是回落 stylekit）。
+    # 现在直接验那条路径：把 design.json 放进 work/，resolve_style 必须解出**同一个**设计，
+    # 且颜色回到 tuple（list 会让 _bg() 的缓存键不可哈希）。
+    import designkit as DK
+    import render as R
+    dpath = os.path.join(w, "design.json")
+    with open(dpath, "w", encoding="utf-8") as fh:
+        _json.dump(_sample_design("并行渲染主题序列化"), fh, ensure_ascii=False)
+    sub_script = {"title": "t", "lines": [{"text": "x"}]}
+    got = R.resolve_style(sub_script, w, verbose=False)
+    assert got.get("style", "").startswith("design:"), \
+        "子进程重解没有走 design.json（会画出另一部片）：%r" % (got.get("style"),)
+    assert isinstance(got["theme"]["bg"], tuple), (
+        "重解后主题色仍是 list，_bg() 会 TypeError（这正是被修的 bug）：%r"
+        % (got["theme"]["bg"],))
+    assert got["theme"]["bg"] == th["bg"], "重解出的主题与父进程不一致（并行会画出不同的片）"
+    return "主题可哈希 + JSON 往返 + 按 design.json 重解一致"
 
 
 def _load_scenes_mod():
@@ -884,9 +959,9 @@ def _load_scenes_mod():
         return None
 
 def t_sfx_content_seed():
-    """v0.7：音效 seed 必须随内容变化，但 legacy 路径必须逐样本不变。
+    """音效 seed 必须随内容变化，但 legacy 路径必须逐样本不变。
 
-    - 不传 style/content_fp -> 两次渲染逐样本相同（v0.4 兼容，不破老片）；
+    - 不传 style/content_fp -> 两次渲染逐样本相同（legacy 兼容，不破老片）；
     - 传了不同 content_fp  -> 必须不同（否则跨片音效还是"都一样"）；
     - 同一 content_fp      -> 逐样本相同（可复现，是程序化视频的底线）。
     """
@@ -904,7 +979,7 @@ def t_sfx_content_seed():
         legacy_a, legacy_b = build(), build()
     except Exception:                                       # noqa: BLE001
         return "skip"                                       # sfxkit 不可用
-    assert np.array_equal(legacy_a, legacy_b), "legacy 两次渲染不一致（v0.4 兼容被破坏）"
+    assert np.array_equal(legacy_a, legacy_b), "legacy 两次渲染不一致（逐样本兼容被破坏）"
     a = build(style="tech-deep", content_fp="aaaa1111", key="Dm")
     b = build(style="tech-deep", content_fp="bbbb2222", key="Dm")
     assert not np.array_equal(a, b), "不同内容指纹得到相同音效轨：跨片音效仍一模一样"
@@ -914,10 +989,10 @@ def t_sfx_content_seed():
 
 
 def t_audio_separation():
-    """v0.7：混音侧 duck 默认必须加深（片内配乐给音效让位）。
+    """混音侧 duck 默认必须加深（片内配乐给音效让位）。
 
     直接读 render.py 的常量文本而不是跑全链：这条断言盯的是"默认值没被改回去"
-    （v0.4 的 3.0 dB 在段落过门时配乐几乎和音效等高，是"听起来像同一套"的成因之一）。
+    （3.0 dB 这类浅值在段落过门时配乐几乎和音效等高，是"听起来像同一套"的成因之一）。
     """
     import re
     path = os.path.join(HERE, "render.py")
@@ -925,7 +1000,7 @@ def t_audio_separation():
     m = re.search(r"duck_default\s*=\s*([0-9.]+)", src)
     assert m, "render.py 里找不到 duck_default"
     base = float(m.group(1))
-    assert base >= 3.5, "duck_default=%.1f dB 太浅（v0.7 要求 >= 3.5）" % base
+    assert base >= 3.5, "duck_default=%.1f dB 太浅（要求 >= 3.5）" % base
     for sid, want in (("mono", 3.0), ("cinema", 5.5), ("epic", 5.5)):
         mm = re.search(r'"%s"\s*:\s*([0-9.]+)' % sid, src)
         assert mm, "render.py 里找不到风格 %s 的 duck 值" % sid
@@ -934,7 +1009,7 @@ def t_audio_separation():
 
 
 def t_voice_priority():
-    """v0.7.1 旁白优先：人声出现时背景必须再压，人声间隙背景恢复。
+    """旁白优先：人声出现时背景必须再压，人声间隙背景恢复。
 
     以前配乐基线只比旁白低 1.5 dB，视频以旁白为主时观众要费力分辨字。
     修法：`mix_film` 用旁白包络做侧链——人声处配乐 -6 dB、音效 -3 dB，间隙回原电平。
@@ -972,7 +1047,7 @@ def t_voice_priority():
 
 
 def t_music_gain_default():
-    """v0.7.1：配乐默认增益必须是 -12 dB（beside 人声），不是旧版的 -1.5。
+    """配乐默认增益必须是 -12 dB（beside 人声），不是 -1.5。
 
     这条盯的是 `render.st_audio` 的默认值：`mus.get("gain_db", -12.0)`。
     直接读源码文本，避免"跑全链才知道默认值"。
@@ -984,7 +1059,7 @@ def t_music_gain_default():
 
 
 def t_snr_guard():
-    """v0.7.1 SNR 兜底：背景天然太响时，混音后必须自己把它压到"人声听得清"。
+    """SNR 兜底：背景天然太响时，混音后必须自己把它压到"人声听得清"。
 
     构造一段人声 + 一段刻意很响的配乐（比人声高 10 dB），不设侧链、只靠 guard：
     `mix_film(guard_snr_db=12)` 后实测人声活跃区的 人声/背景 必须 >= 12 dB，
@@ -1021,11 +1096,11 @@ def t_mix_no_voice():
     assert abs(float(np.max(np.abs(out))) - 0.2) < 1e-5, "无旁白时配乐被改动了（峰值 %.3f）" % float(np.max(np.abs(out)))
     return "无旁白时背景不被压"
 
-# ------------------------------------------------------------------ v0.7.2 新增（全项目深审）
+# ------------------------------------------------------------------ 音频入口边界
 def t_audio_edge_inputs():
     """39 音频入口的边界：极短旁白不能崩、NaN/Inf 必须拒绝、seg=0 不许死循环。
 
-    这几条都是"真跑一次就会遇到"的输入。v0.7.1 及以前的行为：
+    这几条都是"真跑一次就会遇到"的输入。没有守卫时的行为：
       * voice_env 在极短音频上 np.convolve(mode="same") 返回核长 -> np.maximum 广播失败；
       * duck_voice 在"旁白比背景短"时包络与背景长度不同 -> 广播失败；
       * wav_write 对 NaN 做 clip 再 astype(int16)，把 NaN 静默写成 0（写出损坏 WAV 却不报错）；
@@ -1066,7 +1141,7 @@ def t_audio_edge_inputs():
 def t_report_single_source():
     """40 QC 报告落点只能有一个来源：--out 的目录。
 
-    v0.7.2 修的真 bug：all/mux/qa 用 dirname(abspath(out))，accept 用
+    真 bug：all/mux/qa 用 dirname(abspath(out))，accept 用
     dirname(abspath(work))/out。--out 指到 deliver/ 时，签核更新的是另一份没人
     交付的文件，交付出去的那份仍是"未签核"——正好打穿"报告是交付凭据"这条承诺。
     """
@@ -1108,7 +1183,7 @@ def t_empty_ledger_not_pass():
 def t_stage_io_no_phantom_output():
     """42 单阶段连跑不许报"自己的产物不见了"（假 stale）。
 
-    v0.7.2 修：stagewatch 的 STAGE_IO[style].outputs 里把 voice_plan.json 也算成
+    stagewatch 的 STAGE_IO[style].outputs 里把 voice_plan.json 也算成
     style 的产物，而它其实是 tts 阶段写的（render.py 的 st_tts）。于是 --stage style
     连跑两次，第二次必然报"产物 voice_plan.json 不见了"；打开 --strict-stale 就变成
     硬失败——SKILL.md 第 3 步（全新项目第一条生产命令）自己走不通。
@@ -1132,27 +1207,42 @@ def t_stage_io_no_phantom_output():
 def t_theme_overrides_linted():
     """43 theme_overrides 必须参与主题体检（否则用户能造出"看不清"的成片）。
 
-    v0.7.2 修的真 bug：render.resolve_style 以前只体检**基础主题**
+    真 bug：render.resolve_style 以前只体检**基础主题**
     （ST.THEMES[theme_id]），而 scenes 实际用的是 plan[theme]（基础主题 + film.json 的
     visual.theme_overrides）。于是把 ink/bg 调成低对比度时体检照样 PASS，渲完才发现字幕看不清。
     实测 overrides ink=[30,30,30]/bg=[10,10,10]：基础主题 lint 为空，最终主题 lint 报对比度 1.09。
     """
     import stylekit as ST
-    base = {'title': 'x', 'style': 'auto',
-            'lines': [{'id': 'l01', 'kind': 'body', 'text': 'y'}]}
-    p = ST.resolve_script_style(dict(base, visual={'theme_overrides': {
-        'ink': [30, 30, 30], 'bg': [10, 10, 10]}}))
-    assert ST.theme_lint(ST.THEMES[p['theme_id']]) == [], \
-        "前提变了：基础主题本身就有 lint 问题，这条断言失去意义"
-    bad = ST.theme_lint(p['theme'])
+    # 没有"基础主题 vs 最终主题"的区分了（内置主题表已删），
+    # 但"overrides 之后必须重新 lint"这条规则仍然要守：
+    # 直接把设计主题改成低对比度，theme_lint 必须抓到。
+    _d, _plan43 = _design_plan("theme_overrides 体检")
+    base_th = _plan43["theme"]
+    assert ST.theme_lint(base_th) == [], \
+        "前提变了：设计主题本身就有 lint 问题，这条断言失去意义"
+    dirty = ST.apply_theme_overrides(base_th, {"ink": [30, 30, 30], "bg": [10, 10, 10]})
+    bad = ST.theme_lint(dirty)
     assert bad, '低对比度的 theme_overrides 没被 lint 抓到（用户能造出看不清的字幕）'
-    src = open(os.path.join(HERE, "render.py"), encoding="utf-8").read()
-    assert "ST.theme_lint(plan.get('theme')" in src or 'ST.theme_lint(plan.get("theme")' in src, \
-        "render.resolve_style 仍在体检基础主题而不是最终主题"
+    # 体检的位置在 designkit（design_to_plan 里就 lint，不过直接抛）。
+    # 这里改查**真正干活的地方**——早先查 render.py 的源码文本，那只是"哪个文件里写了这行"，
+    # 一旦重构搬家就会误报（本次就是这样：lint 逻辑搬进 designkit 后断言还在查 render）。
+    # 更硬的检查：直接把一份低对比度主题喂给 design_to_plan，必须抛。
+    import designkit as DK
+    dirty_design = json.loads(json.dumps(_sample_design("theme_overrides 体检")))
+    dirty_design["visual"]["palette"]["ink"] = [30, 30, 30]
+    dirty_design["visual"]["palette"]["bg"] = [10, 10, 10]
+    try:
+        DK.design_to_plan(dirty_design)
+    except (ValueError, KeyError, SystemExit) as e:
+        msg = str(getattr(e, "code", None) or e)
+        assert "对比度" in msg or "lint" in msg.lower(), \
+            "低对比度设计被拒了，但错误信息没说是对比度问题：%r" % msg[:120]
+    else:
+        raise AssertionError("低对比度主题竟然通过了 design_to_plan（体检失效，能造出看不清的字幕）")
     return "最终主题参与体检（%s）" % "；".join(bad)[:60]
 
 
-# ------------------------------------------------------------------ v0.8.0 用例
+# ------------------------------------------------------------------ 词级时间戳 / 画幅 / 依赖 / 批量
 def t_word_events():
     """44 词级时间戳：规整/裁剪平移/单调兜底/词锚点解析（不联网）。
 
@@ -1227,12 +1317,9 @@ def t_golden_determinism():
     import hashlib
     sc = dict(id="l01", kind="hook", start=0.0, dur=4.0, chapter="01 · 测试",
               text="金帧确定性自检", sub="金帧确定性", big="金帧确定性")
+    # 剧本必须显式给设计（内置风格表已删，没有"style": "mono" 这种写法了）。
     script = {"title": "selfcheck", "_total": 8.0}
-    try:
-        plan = __import__("stylekit").resolve_script_style(dict(script, lines=[sc]))
-        script["_style"] = plan
-    except Exception:                                       # noqa: BLE001
-        pass
+    script["_style"] = _design_plan("金帧确定性")[1]
     hs = []
     for _ in range(2):
         fr = mod.draw_frame(sc, 1.25, 4.0, 1.25, script, 37)
@@ -1268,7 +1355,7 @@ def t_dependency_drift():
         np.__version__, pil_ver, getattr(edge_tts, "__version__", "?"))
 
 
-# ------------------------------------------------------------------ v0.8.0 用例（续）
+# ------------------------------------------------------------------ web 载荷 / 金帧
 def t_batch_manifest():
     """48 批量清单解析：两种写法都认、上限卡死、坏条目在**开跑前**报错。
 
@@ -1342,26 +1429,31 @@ def t_tts_backend():
 def t_web_style_payload():
     """50 web 引擎风格载荷：非 legacy 才注入、legacy 必须回落 None（逐字节兼容的前提）。
 
-    v0.8 给 web 引擎加了"跟随风格包"，但兼容性要求是 style=None 时页面输出**逐字节**
-    等于 v0.7。这条守住"什么时候该注入、什么时候必须不注入"这个开关。
+    web 引擎会"跟随风格包"，但兼容性要求是 style=None 时页面输出**逐字节**
+    等于不带载荷的旧输出。这条守住"什么时候该注入、什么时候必须不注入"这个开关。
     """
     import render as R
     try:
         import webengine as we
     except Exception as e:                                  # noqa: BLE001
         return "skip（没有 webengine.py：%s）" % e
-    script = {"title": "x", "style": "cinema",
-              "lines": [{"id": "l01", "kind": "hook", "text": "y"}]}
+    # 没有 legacy 概念了（legacy 入口已被拒绝），所以这里只验"设计项目必须注入载荷"。
+    script = {"title": "x", "lines": [{"id": "l01", "kind": "hook", "text": "y"}]}
+    script["_style"] = _design_plan("web 载荷")[1]
     tl = {"fps": 30, "video": {"out_w": 1280, "out_h": 720}}
-    payload = R._web_style_payload(we, script, tl)
+    try:
+        payload = R._web_style_payload(we, script, tl)
+    except SystemExit as e:
+        raise AssertionError("有 _style 却被当成没有设计：%s" % (e,)) from e
     assert payload is not None, "非 legacy 项目没有生成 style 载荷（页面不会跟随风格）"
     canvas = payload.get("canvas") or {}
     assert int(canvas.get("w") or 0) == 1280 and int(canvas.get("h") or 0) == 720, \
         "画布尺寸没跟着 video 块走：%r" % (canvas,)
-    legacy = {"title": "x", "lines": [{"id": "l01", "kind": "hook", "text": "y"}]}
-    assert R._web_style_payload(we, legacy, tl) is None, \
-        "legacy 项目也注入了 style（v0.7 的逐字节兼容会被打破）"
-    return "非 legacy 注入 %dx%d / legacy 回落 None" % (canvas["w"], canvas["h"])
+    # 没有设计的剧本：必须回落 None（不是"随便注入一套默认风格"）
+    bare = {"title": "x", "lines": [{"id": "l01", "kind": "hook", "text": "y"}]}
+    assert R._web_style_payload(we, bare, tl) is None, \
+        "没有设计的剧本也注入了 style 载荷（等于凭空套一套外观）"
+    return "有设计注入 %dx%d / 无设计回落 None" % (canvas["w"], canvas["h"])
 
 
 def t_golden_frames():
@@ -1408,7 +1500,7 @@ def t_golden_frames():
 
 
 # ============================================================================
-# v0.9：场景语法 + 视觉语言
+# 场景语法 + 视觉语言
 # ============================================================================
 
 def _load_grammar():
@@ -1440,7 +1532,7 @@ def _fake_scenes(G, lines, per=6.0):
 def t_scene_grammar():
     """52 场景语法：10 类都能被选中、选型确定、段长门会降级。
 
-    为什么要有这条：v0.9 之前 quote/emphasis/calm 三种 kind 全部落到 body 绘制器，
+    为什么要有这条：quote/emphasis/calm 三种 kind 全都落到 body 绘制器的话，
     画面永远只有一套骨架。这条断言盯的是"内容 -> 构图"这条链路真的在分流，
     而不是"代码里写了 10 个函数但没人调用"。
     """
@@ -1496,31 +1588,32 @@ def t_scene_grammar():
 def t_visual_languages():
     """53 视觉语言包：8 套结构签名齐全、过体检、且彼此不是同一套。
 
-    为什么要有这条：v0.5 的"风格"只改配色，8 套风格骨架完全一样（用户抱怨的根因）。
+    为什么要有这条：只改配色的"风格"会让 8 套风格骨架完全一样（用户抱怨的根因）。
     这条盯的是"结构签名真的存在且互不相同"——母题/转场/重心偏移任一维度相同不算问题，
     但**五组签名全同**就说明这套语言只是复制粘贴。
     """
+    import designkit as DK
     import stylekit as ST
-    if not hasattr(ST, "VISUAL_LANGUAGES"):
-        return "skip（stylekit 没有 VISUAL_LANGUAGES）"
-    bad = ST.visual_lint_all()
-    assert not bad, "内置视觉语言没过体检: %s" % bad
-    sigs = {}
-    for sid in ST.STYLE_IDS:
-        vl = ST.VISUAL_LANGUAGES[sid]
+    # 没有 8 套内置语言了。验"现场生成的语言"，而且断言更强：
+    # 12 个设计的两两结构签名必须互不相同（以前只要求 8 套里 >=6 种母题）。
+    sigs, motifs, transes = {}, set(), set()
+    designs = DK.sample_designs({"topic": "视觉语言多样性"}, n=12, seed=20260202)
+    for d in designs:
+        plan = DK.design_to_plan(d)
+        vl = plan["language"]
+        bad = ST.visual_lint_language(vl)
+        assert not bad, "%s 的语言包没过体检：%s" % (d["label"], bad[:2])
         key = (str((vl.get("motif") or {}).get("kind")),
                str((vl.get("transition") or {}).get("kind")),
                tuple(sorted((vl.get("bias") or {}).items())))
-        assert vl.get("motion") and vl.get("typography"), "%s 缺 motion/typography 签名" % sid
-        sigs.setdefault(key, []).append(sid)
+        sigs.setdefault(key, []).append(d["label"])
+        motifs.add(str((vl.get("motif") or {}).get("kind")))
+        transes.add(str((vl.get("transition") or {}).get("kind")))
     dup = [v for v in sigs.values() if len(v) > 1]
-    assert not dup, "这些风格的母题/转场/重心完全相同（等于没做结构差异）: %s" % (dup,)
-    motifs = {str((ST.VISUAL_LANGUAGES[s].get("motif") or {}).get("kind")) for s in ST.STYLE_IDS}
-    assert len(motifs) >= 6, "8 套风格只用了 %d 种装饰母题：%r" % (len(motifs), sorted(motifs))
-    return "8 套 / %d 种母题 / %d 种转场 / 无重复签名" % (
-        len(motifs),
-        len({str((ST.VISUAL_LANGUAGES[s].get("transition") or {}).get("kind"))
-             for s in ST.STYLE_IDS}))
+    assert not dup, "这些设计语言签名完全相同（等于只在换色）: %s" % (dup[:2],)
+    assert len(motifs) >= 6, "12 个设计只用了 %d 种装饰母题：%r" % (len(motifs), sorted(motifs))
+    return "12 个设计 / %d 种母题 / %d 种转场 / 无重复签名" % (
+        len(motifs), len(transes))
 
 
 def t_scene_types_single_truth():
@@ -1569,7 +1662,7 @@ def t_scene_types_single_truth():
 def t_silhouette_gate():
     """55 剪影可区分（G13）：8 套风格两两之间构图骨架必须能区分。
 
-    这是 v0.9 的核心验收：如果这条挂了，说明"换风格只是换色"的毛病回来了。
+    这是核心验收：如果这条挂了，说明"换风格只是换色"的毛病回来了。
     工具在 tools/silhouette_qa.py（可选）：缺了 skip，不阻塞 CI。
     """
     root = os.path.dirname(os.path.dirname(os.path.dirname(HERE)))
@@ -1612,6 +1705,499 @@ def t_silhouette_gate():
         len(pairs), same_ok if same_ok is not None else "?", same_n if same_n else "?")
 
 
+def t_design_dsl():
+    """56 设计 DSL：采样 -> 校验 -> 转 plan，且 fail-closed（坏设计必须报错）。"""
+    try:
+        import designkit as DK
+    except Exception:                                       # noqa: BLE001
+        return "skip（没有 designkit.py）"
+    ds = DK.sample_designs({"topic": "selfcheck 设计 DSL"}, n=3)
+    assert len(ds) == 3, "采样器只给了 %d 个候选" % len(ds)
+    for d in ds:
+        bad = DK.validate_design(d)
+        assert not bad, "采样器吐出了不合格的设计 %r：%s" % (d.get("id"), bad)
+        plan = DK.design_to_plan(d)
+        assert plan["legacy"] is False, "design 计划不该标 legacy"
+        assert str(plan["style"]).startswith("design:"), "style 应是 design:<id>：%r" % plan["style"]
+        assert len(plan.get("theme") or {}) >= 30, "主题字段太少：%d" % len(plan.get("theme") or {})
+    # 两两必须至少 2 个维度不同（"伪多方案"门禁）
+    for i in range(len(ds)):
+        for j in range(i + 1, len(ds)):
+            d = DK.design_distance(ds[i], ds[j])
+            assert d["n"] >= 2, "候选 %s 与 %s 只差 %d 维" % (ds[i]["id"], ds[j]["id"], d["n"])
+    # fail-closed：删掉必填块必须报错，不能静默回落
+    broken = json.loads(json.dumps(ds[0]))
+    broken["visual"].pop("motif", None)
+    assert DK.validate_design(broken), "缺 motif 竟然通过校验（fail-closed 失效）"
+    # 语义是**不给 seed = 每次都不一样**（需求是"每条视频都不同"），
+    # 给 seed 才可复现。两条都要测，否则改错了任一边都发现不了。
+    x1 = [d["id"] for d in DK.sample_designs({"topic": "selfcheck 设计 DSL"}, n=3)]
+    x2 = [d["id"] for d in DK.sample_designs({"topic": "selfcheck 设计 DSL"}, n=3)]
+    assert x1 != x2, "同一 brief 两次采样完全相同（那就是把模板藏进了哈希里）"
+    y1 = [d["id"] for d in DK.sample_designs({"topic": "selfcheck 设计 DSL"}, n=3, seed=42)]
+    y2 = [d["id"] for d in DK.sample_designs({"topic": "selfcheck 设计 DSL"}, n=3, seed=42)]
+    assert y1 == y2, "给了 seed 竟然不可复现（回归/文档示例就不可信了）"
+    return "3 候选 / 校验全过 / 两两 >=2 维 / 缺字段必报错 / 默认每次不同 + seed 可复现"
+
+
+def t_no_templates():
+    """57 零模板：仓库里**不许再有**预设/模板文件（本技能只提供技术，不提供模板）。
+
+    这条是反向断言：预设整个删掉后，
+    如果只是删掉这条检查，就再也拦不住"哪天有人又加一套预设进去"。
+    所以改成**禁止存在**——删掉模板是一次性动作，守住它是长期契约。
+    """
+    root = os.path.dirname(os.path.dirname(os.path.dirname(HERE)))
+    skill = os.path.join(root, "skills", "video-studio")
+    banned = []
+    presets_dir = os.path.join(skill, "presets")
+    if os.path.isdir(presets_dir):
+        n = len([x for x in os.listdir(presets_dir) if x.endswith(".json")])
+        banned.append("presets/ 目录还在（%d 个 json）" % n)
+    for name in ("presetkit.py",):
+        if os.path.exists(os.path.join(skill, "scripts", name)):
+            banned.append("scripts/%s 还在" % name)
+    assert not banned, ("本技能不提供模板，这些必须删掉：%s；"
+                        "要自定义请写 design.json（技术原语仍在，只是不再有现成目录）"
+                        % "；".join(banned))
+    # 同时确认"现场采样"是唯一方式，且**每次都新**：
+    #   · 同一 brief 两次 -> 必须不同（否则等于模板藏在哈希里，用户要新片只能改措辞）
+    #   · 给 seed -> 必须可复现（回归与文档示例需要一个稳定值）
+    try:
+        import designkit as DK
+    except Exception:                                       # noqa: BLE001
+        return "skip（没有 designkit.py）"
+    a = [d["label"] for d in DK.sample_designs({"topic": "零模板校验 A"}, n=2)]
+    b = [d["label"] for d in DK.sample_designs({"topic": "零模板校验 A"}, n=2)]
+    c = [d["label"] for d in DK.sample_designs({"topic": "零模板校验 B"}, n=2)]
+    s1 = [d["label"] for d in DK.sample_designs({"topic": "零模板校验 A"}, n=2, seed=7)]
+    s2 = [d["label"] for d in DK.sample_designs({"topic": "零模板校验 A"}, n=2, seed=7)]
+    assert a != b, "同一 brief 两次采样结果相同（等于把模板藏进了哈希）"
+    assert a != c, "换 brief 采样结果没变（说明其实在套模板）"
+    assert s1 == s2, "给了 seed 竟然不可复现"
+    return "无模板文件；同 brief 两次必不同、换 brief 必变、seed 可复现"
+
+
+def t_brief_constraints():
+    """60 brief 里的要求必须真的生效（自然语言 -> 约束 -> 采样结果）。
+
+    这条防的是**需求被静默吃掉**：propose._brief_of 若把整句 --brief 塞进 topic，
+    must_have/avoid 恒为空数组，于是"深蓝配色的科技解说"采出来是 h087 / h316（橙 / 紫）。
+    用户看到的需求和结果无关，而且没有任何提示——比报错更糟。
+
+    三件事都要验：
+      ① 自由文本能解析成 must_have / avoid（含否定词归到 avoid）；
+      ② 配色约束按**色相窗口**生效（不是按 8 个族名）；
+      ③ avoid 真的把色相排除掉。
+    """
+    import re
+    try:
+        import propose as PP
+        import designkit as DK
+        import stylekit as ST
+    except Exception:                                       # noqa: BLE001
+        return "skip（缺 propose/designkit/stylekit）"
+    # ① 解析
+    b1 = PP._brief_of("要深蓝，不要放射线", {"title": "t"})
+    assert b1["must_have"] and "深蓝" in b1["must_have"][0], "must_have 没解析出来：%r" % (b1["must_have"],)
+    assert b1["avoid"] and "放射" in b1["avoid"][0], "avoid 没解析出来：%r" % (b1["avoid"],)
+    b2 = PP._brief_of("随便做个片", {"title": "t"})
+    assert b2["must_have"] == [] and b2["avoid"] == [], "认不出要求时不该硬凑约束"
+    # ② 配色约束 -> 色相窗口
+    ds = DK.sample_designs({"topic": "深蓝科技", "must_have": ["深蓝"]}, n=2, seed=7)
+    for d in ds:
+        h = DK._design_bg_hue(d)
+        assert h is not None, "取不到底色色相"
+        gap = DK._hue_gap(h, DK._PALETTE_ANCHOR["deep-blue"][0])
+        assert gap <= DK._HUE_WINDOW + 1e-6, (
+            "must_have『深蓝』没生效：底色色相 %.1f° 距 210° 有 %.1f°（窗口 %.0f°）"
+            % (h, gap, DK._HUE_WINDOW))
+    # ③ avoid 真的排除
+    mint = DK._PALETTE_ANCHOR["cool-mint"][0]
+    for i in range(3):
+        d = DK.sample_designs({"topic": "避开薄荷 %d" % i, "avoid": ["薄荷"]}, n=1, seed=i)[0]
+        h = DK._design_bg_hue(d)
+        assert DK._hue_gap(h, mint) > DK._HUE_WINDOW, (
+            "avoid『薄荷』没生效：底色色相 %.1f° 落在薄荷范围（%.0f°±%.0f°）"
+            % (h, mint, DK._HUE_WINDOW))
+    return "解析 2/2；深蓝落入窗口；薄荷 3/3 被排除"
+
+
+def t_stage_standalone():
+    """59 逐 stage 可单独跑：render 里每处 resolve_style 都必须能拿到 work。
+
+    这条守住一类**只在"单跑某个 stage"时才发作**的 bug：
+    `--stage all` 时前面的 stage 已经把 script["_style"] 塞好了，后面全都命中缓存，
+    所以缺参数也看不出来；一旦用户只跑 `--stage frames` / `--stage sfx`，
+    resolve_style 读不到 work/design.json 就报"找不到设计"（实测踩到：
+    frames / sfx 两个 stage 单跑必挂，sfx 还是 NameError——函数里压根没有 work 这个名字）。
+
+    为什么用 AST 而不是真的跑每个 stage：跑一遍 = 要 TTS 联网 + 全片渲染，几十秒起步，
+    不适合放进 20 秒的自检。静态检查能抓住"参数没传/名字不存在"这一整类问题，
+    而这正是本次的真实缺陷形态。
+    """
+    import ast
+    src_path = os.path.join(HERE, "render.py")
+    tree = ast.parse(open(src_path, encoding="utf-8").read())
+    bad = []
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.FunctionDef):
+            continue
+        args = [a.arg for a in node.args.args] + [a.arg for a in node.args.kwonlyargs]
+        for sub in ast.walk(node):
+            if not isinstance(sub, ast.Call):
+                continue
+            fn = sub.func
+            name = getattr(fn, "id", None) or getattr(fn, "attr", None)
+            if name != "resolve_style":
+                continue
+            # resolve_style(script, work) 的第二位必须是本函数能拿到的变量
+            if len(sub.args) >= 2:
+                second = sub.args[1]
+                vname = getattr(second, "id", None)
+                if vname and vname not in args and vname not in ("work",):
+                    # 明确允许 a.work 这类属性访问（不是 Name）
+                    bad.append("%s(): resolve_style 的 work 参数用了 %r，但该函数没有这个变量"
+                               % (node.name, vname))
+            else:
+                bad.append("%s(): resolve_style 没传 work（单跑该 stage 会读不到 design.json）"
+                           % node.name)
+    assert not bad, "；".join(bad[:4])
+    return "render 里 %d 处 resolve_style 全部带得上 work" % sum(
+        1 for n in ast.walk(tree) if isinstance(n, ast.Call)
+        and (getattr(n.func, "id", None) or getattr(n.func, "attr", None)) == "resolve_style")
+
+
+def t_proposal_gate():
+    """58 提案闸：没确认时必须判 draft/absent，确认后才放行；坏文件判 broken。"""
+    try:
+        import propose as PP
+    except Exception:                                       # noqa: BLE001
+        return "skip（没有 propose.py）"
+    with tempfile.TemporaryDirectory() as work:
+        status, detail = PP.proposal_state(work)
+        assert status == "absent", "空目录应判 absent，收到 %r" % status
+        os.makedirs(work, exist_ok=True)
+        with open(os.path.join(work, "proposal.json"), "w", encoding="utf-8") as fh:
+            json.dump({"schema": 1, "rev": 1, "status": "draft",
+                       "candidates": [{"id": "A"}, {"id": "B"}]}, fh)
+        status, _ = PP.proposal_state(work)
+        assert status == "draft", "有草案但没确认应判 draft，收到 %r" % status
+        with open(os.path.join(work, "proposal.json"), "w", encoding="utf-8") as fh:
+            fh.write("{broken json")
+        try:
+            status, _ = PP.proposal_state(work)
+        except SystemExit:
+            status = "broken"
+        assert status == "broken", "坏 JSON 应判 broken，收到 %r" % status
+    return "absent / draft / broken 三档判定正确"
+
+
+
+
+def t_subtitle_style():
+    """61 字幕样式可定制：design.visual.subtitle 必须真的改变像素，缺省逐像素不变。
+
+    为什么必须有这条：字幕字号/位置/背板过去是 filmkit 的**模块常量**，任何两条片子
+    的字幕带都一模一样 —— 这正是用户说的"跨片大面积重复"。改成设计字段后，最容易
+    出现的退化是"字段读进来了但没传给 draw_subtitle"（写完不生效，实测踩过）。
+    所以这里验行为：同一个 theme、同一段文字，换字幕参数必须像素不同；
+    不传参数时必须与不传该字段的调用逐像素一致（老项目不漂）。
+    """
+    import numpy as _np
+    import designkit as DK
+    # 用一套现场采样设计里的主题，避免依赖内置主题表（已删）
+    d = DK.sample_designs({"topic": "字幕样式自检"}, n=1, seed=3)[0]
+    plan = DK.design_to_plan(d)
+    theme = plan["theme"]
+    text = "这是一句用来测试字幕样式是否真的生效的中文字幕"
+    base = K.Image.new("RGB", (K.W, K.H), tuple(theme["bg"]))
+    default_img = K.draw_subtitle(base.copy(), text, theme=theme)
+    kw = K.subtitle_kwargs(plan)
+    assert kw.get("size") and kw.get("align") in ("center", "left"), (
+        "subtitle_kwargs 没把设计的字幕参数带出来：%r" % (kw,))
+    styled = K.draw_subtitle(base.copy(), text, theme=theme, **kw)
+    a = _np.asarray(default_img, dtype=_np.int16)
+    b = _np.asarray(styled, dtype=_np.int16)
+    assert int(_np.abs(a - b).max()) > 0, "字幕参数没有改变任何像素（字段写了不生效）"
+    # 缺省必须等价于旧调用（老 design.json 逐像素不变）
+    assert K.subtitle_kwargs({}) == {}, "没有 subtitle 的计划必须返回空 kw（保持旧像素）"
+    assert K.subtitle_kwargs({"subtitle": {}}) == {}, "空 subtitle 也必须是空 kw"
+    return "字幕参数改变像素；缺省等价旧调用（size=%s align=%s）" % (kw.get("size"), kw.get("align"))
+
+
+def t_layout_cycle():
+    """62 片内版式轮换：layout_cycle 真的让不同章节换骨架，同章必须稳定。
+
+    用户原则 5：同一部片不能"长时间一张版式"。design.visual.layout 是单值，
+    grammar 把它当全片默认 → 8 段片子 8 屏同骨架。这条验三件事：
+      ① 有 layout_cycle 时，不同 chapter 拿到不同版式；
+      ② 同一个 chapter 内所有段版式一致（不能每句都跳）；
+      ③ 没有 layout_cycle 时行为与旧版一致（全用 layout_default）。
+    """
+    import grammar as G
+    scenes = [
+        {"id": "a1", "kind": "body", "chapter": "第一章", "start": 0.0, "end": 4.0, "dur": 4.0},
+        {"id": "a2", "kind": "body", "chapter": "第一章", "start": 4.0, "end": 8.0, "dur": 4.0},
+        {"id": "b1", "kind": "body", "chapter": "第二章", "start": 8.0, "end": 12.0, "dur": 4.0},
+        {"id": "b2", "kind": "body", "chapter": "第二章", "start": 12.0, "end": 16.0, "dur": 4.0},
+    ]
+    plan = {"chapter_layout": {}, "layout_default": "left-stack",
+            "layout_cycle": ["left-stack", "center-stack"]}
+    scenes = [dict(s) for s in scenes]
+    G.plan_scenes(scenes, {"lines": []}, plan)
+    got = {s["id"]: s["scene_layout"] for s in scenes}
+    assert got["a1"] == got["a2"], "同一章内版式必须稳定，实际 %s" % (got,)
+    assert got["b1"] == got["b2"], "同一章内版式必须稳定，实际 %s" % (got,)
+    assert got["a1"] != got["b1"], "不同章节应轮换版式，实际两章都是 %s" % (got["a1"],)
+    # 没有 cycle 时回到旧行为
+    scenes2 = [dict(s) for s in scenes]
+    G.plan_scenes(scenes2, {"lines": []}, {"chapter_layout": {}, "layout_default": "split-right"})
+    assert all(s["scene_layout"] == "split-right" for s in scenes2), \
+        "没有 layout_cycle 时必须全用 layout_default（旧行为）"
+    return "两章轮换 %s -> %s；同章稳定；无 cycle 时回落 layout_default" % (got["a1"], got["b1"])
+
+
+def t_brief_constraint_robustness():
+    """63 带约束的 brief 不许高概率直接失败。
+
+    实测过的真缺陷：配色候选去重按 24° 分桶，而 must_have「深蓝」把色相窗口压到 52°，
+    n=3 时约一半概率抛 ValueError；「暖纸色 + 女声」20/20 全失败。用户第一步就撞墙。
+    修法改成"色相距离 + 结构差异"分档后，这里用 20 次独立采样守回归。
+    """
+    import propose as PP
+    import designkit as DK
+    briefs = ["深蓝", "纪录片，暖纸色，缓慢，女声", "科技发布会，深蓝，要遮幅"]
+    for text in briefs:
+        b = PP._brief_of(text, {"title": "t"})
+        for _ in range(6):
+            try:
+                DK.sample_designs(b, n=3)
+            except ValueError as e:
+                raise AssertionError("brief %r 采样失败：%s" % (text, str(e)[:200])) from e
+    return "3 种带约束 brief × 6 次 = 18 次 n=3 采样全部成功"
+
+
+def t_removed_apis_fail_closed():
+    """64 已删除的 API 必须"明确报错/非零退出"，不许 NameError、假绿或静默 fallback。
+
+    删内置风格表时留下了一批**死路径**：stylekit 的 --list/--show NameError、
+    --lint 空表 exit 0（假绿）、filmkit 的 resolve_theme/style_plan 吞异常回落到写死的
+    写死的主题（静默降级 = 用模板出片）。这三种都必须绝迹。
+    """
+    import subprocess as _sp
+    import stylekit as ST
+    import filmkit as FK
+    # ① stylekit.resolve_script_style 必须 raise 且带指引
+    try:
+        ST.resolve_script_style({"title": "t", "lines": []})
+    except (ValueError, KeyError, SystemExit) as e:
+        msg = str(getattr(e, "code", None) or e)
+        assert "propose.py" in msg, "报错必须给迁移指引（要提到 propose.py）：%r" % msg[:120]
+    else:
+        raise AssertionError("没有设计的剧本竟然解析出了计划")
+    # ② stylekit CLI 三个动作必须非零退出（不许假绿/NameError traceback）
+    for flag in ("--list", "--lint"):
+        p = _sp.run([sys.executable, os.path.join(HERE, "stylekit.py"), flag],
+                    capture_output=True, text=True, timeout=60)
+        assert p.returncode == 2, "stylekit.py %s 应 exit 2（能力已移除），实际 %d" % (flag, p.returncode)
+        assert "Traceback" not in (p.stderr or ""), "stylekit.py %s 不该抛 traceback" % flag
+    # ③ filmkit 的静默回落必须改成明确报错
+    for fn in (FK.resolve_theme, FK.style_plan):
+        try:
+            fn({"title": "t", "lines": []})
+        except (ValueError, KeyError) as e:
+            assert "propose" in str(e).lower() or "design" in str(e).lower(), \
+                "%s 的报错要给迁移指引：%r" % (fn.__name__, str(e)[:120])
+        else:
+            raise AssertionError("%s 在无设计时静默返回了兜底主题（模板残留）" % fn.__name__)
+    # ④ designkit 的配色采样示例不许崩（--list-palettes 曾 KeyError: family）
+    p = _sp.run([sys.executable, os.path.join(HERE, "designkit.py"), "--list-palettes", "--json"],
+                capture_output=True, text=True, timeout=120)
+    assert p.returncode == 0, "designkit.py --list-palettes 崩了：%s" % (p.stderr or p.stdout)[:200]
+    return "resolve_script_style/CLI/filmkit 全部 fail-closed；--list-palettes 可跑"
+
+
+def t_audio_overrides():
+    """65 design.audio 的音量/音效参数必须真的落进 script。
+
+    实测过的真缺陷：design.json 的 audio.music.gain_db / duck_db 与 audio.sfx.enabled
+    / density / gain_db 一直被 validate_design 接受、却从来没有渲染代码读它们 ——
+    用户把 sfx.enabled 写成 false，成片照样出 8 条音效。
+    现在的契约：**film.json 显式写了的 > design 的值 > 模块默认**。
+    """
+    import designkit as DK
+    d = DK.sample_designs({"topic": "声音参数自检"}, n=1, seed=5)[0]
+    d = json.loads(json.dumps(d))
+    d["audio"]["music"]["gain_db"] = -7.5
+    d["audio"]["music"]["duck_db"] = 9.0
+    d["audio"]["sfx"] = {"enabled": False, "density": "rich", "gain_db": -3}
+    plan = DK.design_to_plan(d)
+    ov = plan.get("audio_overrides") or {}
+    assert abs(float(ov["music"]["gain_db"]) + 7.5) < 1e-9, "music.gain_db 没进计划"
+    assert abs(float(ov["music"]["duck_db"]) - 9.0) < 1e-9, "music.duck_db 没进计划"
+    assert ov["sfx"]["enabled"] is False, "sfx.enabled 没进计划"
+    import render as R
+    # 剧本里没写 -> 用 design 的值
+    s1 = {"title": "t", "lines": []}
+    R._apply_audio_overrides(s1, plan)
+    assert s1["sfx"]["enabled"] is False and abs(s1["music"]["gain_db"] + 7.5) < 1e-9, \
+        "design 的声音参数没有填进 script：%r" % (s1,)
+    # 剧本显式写了 -> 以剧本为准（用户手里 film.json 是最终裁决权）
+    s2 = {"title": "t", "lines": [], "music": {"gain_db": -1.0}, "sfx": {"enabled": True}}
+    R._apply_audio_overrides(s2, plan)
+    assert s2["music"]["gain_db"] == -1.0 and s2["sfx"]["enabled"] is True, \
+        "film.json 的显式值被 design 覆盖了：%r" % (s2,)
+    return "design.audio -> plan -> script 贯通；film.json 显式值优先"
+
+
+def t_design_ledger():
+    """66 片间去重台账：确认过的设计要记住，下次提案主动避开；可关可查。
+
+    用户原则 5：不同视频的整体风格不能大面积重复。只保证"同一 brief 两次采样不同"
+    （nonce），但没有记忆——连拍同题材仍可能撞到相近设计。台账补上这一环。
+    这条验四件事：① confirm 后写台账；② 提案会读台账并报告距离；
+    ③ 台账路径可被环境变量重定向（绝不污染用户真实台账）；④ --no-ledger 可关闭。
+    """
+    import tempfile
+    import subprocess as _sp
+    tmp = tempfile.mkdtemp(prefix="vs_ledger_selfcheck_")
+    ledger = os.path.join(tmp, "ledger.json")
+    env = dict(os.environ, PYTHONIOENCODING="utf-8", VIDEO_STUDIO_LEDGER=ledger)
+    script = {"title": "台账自检", "lines": [
+        {"id": "l01", "kind": "hook", "text": "第一句话。"},
+        {"id": "l02", "kind": "body", "text": "第二句话，讲一件具体的事。"},
+        {"id": "l03", "kind": "outro", "text": "结束。"}]}
+    film = os.path.join(tmp, "film.json")
+    with open(film, "w", encoding="utf-8") as fh:
+        json.dump(script, fh, ensure_ascii=False)
+    pp = os.path.join(HERE, "propose.py")
+
+    def _run(args):
+        r = _sp.run([sys.executable, pp] + args, cwd=tmp, capture_output=True,
+                    text=True, encoding="utf-8", errors="replace", env=env, timeout=300)
+        assert r.returncode == 0, "propose.py %s 失败：%s" % (args[0], (r.stderr or r.stdout)[-300:])
+        return r
+
+    _run(["--brief", "深蓝科技解说", "--script", film, "--n", "3"])
+    assert not os.path.exists(ledger), "还没 confirm 就写台账了（草稿不该记）"
+    _run(["--confirm", "--candidate", "A"])
+    assert os.path.exists(ledger), "confirm 之后没有写台账：%s" % ledger
+    data = json.load(open(ledger, encoding="utf-8"))
+    assert len(data.get("designs") or []) == 1, "台账条数不对：%r" % (data,)
+    row = data["designs"][0]
+    assert row.get("fingerprint") and isinstance(row.get("design"), dict), "台账记录缺字段"
+    # 第二次提案：必须能读到台账（人读输出里有一行"片间去重"）
+    r = _run(["--brief", "深蓝科技解说", "--script", film, "--n", "3"])
+    assert "片间去重" in r.stdout, "提案没有报告台账状态：%s" % r.stdout[-400:]
+    # --show-ledger 能查；--no-ledger 能关
+    r = _run(["--show-ledger"])
+    assert row["fingerprint"] in r.stdout, "--show-ledger 没列出刚记的指纹"
+    r = _run(["--brief", "深蓝科技解说", "--script", film, "--n", "3", "--no-ledger"])
+    assert "--no-ledger" in r.stdout, "--no-ledger 没有给出关闭提示"
+    return "草稿不记 / confirm 记账 / 提案读取并报告 / --show-ledger 可查 / --no-ledger 可关"
+
+
+def t_duration_target():
+    """67 时长要求真的被接住：brief 里的「2 分钟」要影响设计，渲染时对账。
+
+    过去 `_brief_of` 把 duration_target 恒填 None —— 用户写「做个 2 分钟的片」等于没写，
+    成片永远按台词长度出（实测 23s / 30s）。这条守三件事：
+      ① 中文/阿拉伯数字的常见时长说法都能解析；
+      ② 解析出的时长进 design.structure.target_sec，并决定候选段落数；
+      ③ 渲染时按"目标 vs 实测"对账（差 >15% 告警，但不截断旁白）。
+    """
+    import propose as PP
+    import designkit as DK
+    cases = {"2分钟": 120.0, "做个90秒的短视频": 90.0, "一分钟半": 90.0,
+             "3分30秒": 210.0, "2.5分钟": 150.0, "两分钟": 120.0}
+    for text, want in cases.items():
+        got = PP.parse_duration(text)
+        assert got is not None and abs(got - want) < 1e-6, \
+            "时长解析 %r 得到 %r，期望 %r" % (text, got, want)
+    assert PP.parse_duration("深蓝科技解说") is None, "没有时长时不该硬凑"
+    assert PP.parse_duration("两小时") is None, "超出 3–1800s 契约范围应拒绝"
+    b = PP._brief_of("深蓝，科技，2分钟，硬切", {"title": "t"})
+    assert b.get("duration_target") == 120.0, "brief 没接住时长：%r" % (b,)
+    d = DK.sample_designs(b, n=2, seed=9)[0]
+    assert d["structure"].get("target_sec") == 120.0, \
+        "目标时长没进设计：%r" % (d["structure"],)
+    plan = DK.design_to_plan(d)
+    assert plan.get("target_sec") == 120.0, "目标时长没进计划：%r" % (plan.get("target_sec"),)
+    return "6 种时长说法解析正确；进 design/plan；超范围拒绝"
+def t_zoom_stability():
+    """68 缩放取景的帧间稳定性（抖动回归）。
+
+    为什么要有这条：底图把颗粒烘进去后用 NEAREST 逐帧直采，采样网格随 s 整体跳变，
+    颗粒图案跟着错位 1px —— 用户实测的原话是"生成的视频有明显的抖动感"，
+    而单帧闪烁门禁（8x8 分块比较前后帧平均）对这类亚像素沸腾**完全不敏感**。
+    断言：同一主题从 s=1.0 缓推到 s=1+push 的过程中，相邻两帧最大差 <= 2 灰阶。
+    端点直采实测抖动 4~6，改成端点预烘 + blend 后 0~1。
+    """
+    mod = _load_scenes_mod()
+    if mod is None:
+        return "skip（没有 assets/scenes.py）"
+    import numpy as np
+    push = 0.12
+    th = {"id": "zoom-stab", "bg": (28, 30, 36), "bg2": (18, 19, 24), "texture": "paper",
+          "grain": 5.0, "grain_freq": 0.31, "vignette": 0.2, "vignette_tint": (0, 0, 0),
+          "texture_alpha": 0.03, "push": push}
+    frames = [np.asarray(mod._bg_plate(th, 1.0 + push * i / 19.0), dtype=np.int16)
+              for i in range(20)]
+    worst_max = 0
+    worst_mean = 0.0
+    for i in range(1, len(frames)):
+        d = np.abs(frames[i] - frames[i - 1])
+        worst_max = max(worst_max, int(d.max()))
+        worst_mean = max(worst_mean, float(d.mean()))
+    assert worst_max <= 2, ("缩放取景帧间跳变 %d 灰阶（>2）：底图高频纹理被 NEAREST 重排，"
+                            "观感就是满屏噪点沸腾" % worst_max)
+    # 均值守住 0.6：8-bit 输出下慢速缓推必然出现"整片 1 灰阶"的量化台阶，
+    # 首帧端点与 s≈1.006 之间实测 mean≈0.44 —— 这是量化噪声，不是图案错位。
+    # 真正能区分"错位沸腾"的是 max：旧实现 4~6，新实现 <=1。
+    assert worst_mean <= 0.6, "缩放取景帧间平均差 %.3f（>0.6，疑似整屏跳变）" % worst_mean
+    return ("20 帧缓推：最大帧间差 %d 灰阶 / 均值 %.3f（旧 NEAREST 直采为 4~6 灰阶）"
+            % (worst_max, worst_mean))
+
+
+def t_asr_lost_diagnostics():
+    """69 ASR 掉分可定位（低召回必须说清"掉在哪几个字"）。
+
+    为什么要有这条：实测 ASR 回读 0.813~0.844 是常态（中文专名 + 同音字），只报一个
+    百分比，agent 只能盲目放宽阈值。这条断言盯的是"低于 pass 线时，报告必须给出
+    没对上的字符（全局 + 最差段落）"，且判分本身仍然是纯函数、不加载模型。
+    """
+    cand = os.path.join(HERE, "qaasr.py")
+    if not os.path.exists(cand):
+        return "skip（没有 qaasr.py）"
+    import importlib.util
+    spec = importlib.util.spec_from_file_location("sc_qaasr", cand)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    scenes = [
+        {"id": "a", "start": 0.0, "end": 3.0, "voice_start": 0.4,
+         "text": "这是用 DeepSeek 生成的声音与画面。"},
+        {"id": "b", "start": 3.0, "end": 6.0, "voice_start": 3.4,
+         "text": "先定脚本，再定声音，最后才是画面。"},
+    ]
+    # ASR 把 DeepSeek 听成"迪普西克"、把"再定"听成"在订"——低召回但不丢句
+    segments = [
+        {"start": 0.4, "end": 3.0, "text": "这是用 迪普西克 生成的声音与画面"},
+        {"start": 3.4, "end": 6.0, "text": "先定脚本，在订声音，最后才是画面"},
+    ]
+    rep = mod._judge(scenes, segments, recall_pass=0.99, recall_warn=0.5)
+    assert rep["recall"] < 0.99, "构造样例没有触发低召回，断言前提不成立"
+    assert rep.get("lost_top"), "低召回时没有输出 lost_top（掉分字符清单）"
+    assert all("ch" in x and "n" in x for x in rep["lost_top"]), "lost_top 结构不对"
+    lost_lines = [p for p in rep["per_line"] if p.get("lost")]
+    assert lost_lines, "没有段落级 lost（最差段落无法定位）"
+    warns = " ".join(rep.get("warnings") or [])
+    assert "没对上的字" in warns, "低召回时警告里没有掉分字符清单"
+    assert "最差段落" in warns, "低召回时警告里没有最差段落定位"
+    return "lost_top %d 项 / 段落级 %d 段 / 警告 %d 条" % (
+        len(rep["lost_top"]), len(lost_lines), len(rep.get("warnings") or []))
+
+
 CASES = [
     ("1  TTS 缓存校验文本", t_cache_key),
     ("2  sub_window 覆盖长句", t_sub_window),
@@ -1625,7 +2211,7 @@ CASES = [
     ("10 qa 字幕条数校验", t_qa_subs),
     ("11 尾静音裁剪", t_trim),
     ("12 mux 音轨 48kHz", t_mux_48k),
-    ("13 v0.1 调用签名兼容", t_compat),
+    ("13 调用签名兼容", t_compat),
     ("14 qa 帧率校验", t_fps_check),
     ("15 立体声总线", t_stereo_bus),
     ("16 cue_time 三种写法", t_cue_time),
@@ -1645,9 +2231,9 @@ CASES = [
     ("30 门禁账本与签核", t_gates),
     ("31 阶段新鲜度守卫", t_stagewatch),
     ("32 并行渲染主题序列化", t_parallel_frames),
-    ("33 音效跨片可区分（v0.7 内容派生 seed）", t_sfx_content_seed),
-    ("34 配乐/音效片内分离（v0.7 duck 加深）", t_audio_separation),
-    ("35 旁白优先（v0.7.1 背景让位与恢复）", t_voice_priority),
+    ("33 音效跨片可区分（内容派生 seed）", t_sfx_content_seed),
+    ("34 配乐/音效片内分离（duck 加深）", t_audio_separation),
+    ("35 旁白优先（背景让位与恢复）", t_voice_priority),
     ("36 旁白优先默认值（配乐 -12 dB + 侧链）", t_music_gain_default),
     ("37 旁白清晰度 SNR 兜底（背景太响时自动补压）", t_snr_guard),
     ("38 无旁白时混音不受影响", t_mix_no_voice),
@@ -1668,6 +2254,20 @@ CASES = [
     ("53 视觉语言包（结构签名互不相同）", t_visual_languages),
     ("54 场景类型单真值（4 处集合一致）", t_scene_types_single_truth),
     ("55 剪影可区分（G13：换风格不能只是换色）", t_silhouette_gate),
+    ("56 设计 DSL（采样/校验/转计划/fail-closed）", t_design_dsl),
+    ("57 零模板（仓库里不许有预设；采样确定性且随 brief 变化）", t_no_templates),
+    ("58 提案闸（absent/draft/confirmed/broken）", t_proposal_gate),
+    ("59 逐 stage 可单独跑（resolve_style 必须拿得到 work）", t_stage_standalone),
+    ("60 brief 里的要求真的生效（自然语言 -> 约束 -> 采样）", t_brief_constraints),
+    ("61 字幕样式可定制（design.visual.subtitle 真的生效）", t_subtitle_style),
+    ("62 片内版式轮换（layout_cycle：换章即换骨架）", t_layout_cycle),
+    ("63 带约束的 brief 不会高概率采样失败", t_brief_constraint_robustness),
+    ("64 已删除 API 的 fail-closed（不许 NameError / 假绿 / 静默回落）", t_removed_apis_fail_closed),
+    ("65 design.audio 的音量/音效参数真的落进 script", t_audio_overrides),
+    ("66 片间去重台账（确认记账 / 提案避开 / 可关可查）", t_design_ledger),
+    ("67 时长要求真的被接住（brief -> design -> 渲染对账）", t_duration_target),
+    ("68 缩放取景的帧间稳定性（抖动回归）", t_zoom_stability),
+    ("69 ASR 掉分可定位（lost_top / 最差段落）", t_asr_lost_diagnostics),
 ]