@dsh-gis/dsh-video-studio-skill 0.8.1 → 1.0.2

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

@@ -29,7 +29,8 @@
  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/单声线
+  26  （v1.0.0）legacy 已移除：不写 style 必须**报错并给迁移指引**（v0.5 时代这条断言
+      的是"精确落回 Dm/120/seed7/单声线"，D3 把那条路径删了，断言随之反转）
   27  （v0.5.0）内容指纹：同剧本稳定、改标点不换风格、换题材才换
   28  （v0.5.0）声线计划：4 句样片 >=2 把声音，legacy 仍是单声线
   29  （v0.5.0）字体族与主题字幕：换族换缓存键，浅色主题不画黑背板
@@ -55,9 +56,24 @@
   49  （v0.8.0）TTS 后端可替换：注册/注销/未知后端的接口契约
   50  （v0.8.0）web 风格载荷：style=None 时不得注入 __STYLE__（legacy 必须回落）
   51  （v0.8.0）金帧回归：与 assets/golden_frames.json 的像素基线比对
+  52  （v0.9.0）场景语法：10 类构图分流、选型确定性、段长降级门
+  53  （v0.9.0）视觉语言包：8 套结构签名齐全、过体检、彼此不是同一套
+  54  （v0.9.0）场景类型单真值：grammar / filmcheck / scenes / schema 四处集合相等
+  55  （v0.9.0）剪影可区分（G13）：8 套风格两两之间构图骨架必须能区分
+  56  （v1.0.0）设计 DSL：采样->校验->转计划全通；缺必填块必须报错（fail-closed）；
+      同 brief 两次采样一致；两两至少 2 维不同（"伪多方案"门禁）
+  57  （v1.0.1）零模板：仓库里不许存在 presets/ 与 presetkit.py；现场采样必须确定性、
+      且换 brief 必须换结果（否则就是还在套模板）
+  58  （v1.0.0）提案闸：absent / draft / broken 三档判定正确（confirmed 才放行出片）
+  59  （v1.0.1）逐 stage 可单独跑：render 里每处 resolve_style 都必须拿得到 work
+      （只跑 --stage frames / --stage sfx 时缺参数会报"找不到设计"，all 被缓存掩盖）
+  60  （v1.0.1）brief 里的要求真的生效：自然语言要解析成 must_have/avoid，
+      配色约束按色相窗口生效（早先整句被塞进 topic，"深蓝"采出来是橙色）
 
 说明：本文件里 CASES 的**实际条数**是唯一真理，上面的编号表要与它同步。
-v0.8.0 之前这张表停在 43 条而 CASES 已经有 51 条，属于"自检清单自己没被自检"。
+这张表已经被"自己没被自检"坑过两次：v0.8.0 之前停在 43 条而 CASES 已有 51 条；
+v1.0.0 之前停在 51 条而 CASES 已有 58 条（52–58 一条都没列）。
+改 CASES 时请同批改这张表，别让它再次落后。
 """
 import argparse
 import io
@@ -104,11 +120,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 计划。
+# v1.0.1 删掉内置风格表后，"要一份 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)
@@ -451,9 +493,15 @@ 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
@@ -552,79 +600,90 @@ def t_qa_frames():
 
 
 def t_style_kits():
-    """25 风格层：8 套主题过对比度门禁 + 自动选风格能把 8 类题材分开。"""
+    """25 连续配色空间（v1.0.1 替代"8 套主题"）：现场采样的每一套都必须过对比度门禁，
+    且色相真的分散——这条是"没有模板"的硬证据。
+
+    旧断言是"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 已移除（v1.0 / D3）：不写 style 必须报错并给出迁移指引，而不是静默落老外观。
+
+    这条以前盯的是"老项目无痛升级"；D3 之后那句话不再成立——legacy 路径整个删掉了，
+    因为它是同质化的另一半根因（不写 style = 全片一套固定外观 + 120BPM/Dm）。
+    新断言分成两半：① 不给设计时必须**报错**且错误文本指得出下一步；
+    ② 显式给 style 时旧路径仍可用（P3 只停了 auto 与 legacy，没删显式选风格）。
+    """
     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 也不再可用 —— v1.0.1 把内置风格表整个删了。
+    #    和 v1.0 不同：那时"显式选风格"是兼容面；现在连 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
+    # v1.0.1：没有"剧本 -> 自动选风格"了，改为验证"设计采样"的确定性与区分度。
+    # 固定 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,31 +692,35 @@ 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)
+    # v1.0.1：声线计划同样只能从设计来（模板表已删）
+    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
+    # v1.0 / D3：persona 身份表已删，声音身份的唯一表示是 edge voice id。
+    # 断言从"至少 2 个 persona"改成"至少 2 个不同的 voice id"——语义不变，字段换了。
+    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():
@@ -704,11 +767,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
+    # v1.0.1：没有内置主题可借（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)
@@ -841,8 +906,9 @@ def t_parallel_frames():
     """
     import json as _json
     import tempfile
-    import stylekit as ST
-    th = dict(ST.THEMES["tech-deep"])
+    # v1.0.1：不再有内置主题可借，用现场设计的主题（颜色同样是 (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 +920,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"
+    # 子进程路径（v1.0.1 修：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():
@@ -1138,17 +1215,32 @@ def t_theme_overrides_linted():
     实测 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'])
+    # v1.0.1：没有"基础主题 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 仍在体检基础主题而不是最终主题"
+    # v1.0.1：体检的位置从 render 挪到了 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]
 
 
@@ -1227,12 +1319,9 @@ def t_golden_determinism():
     import hashlib
     sc = dict(id="l01", kind="hook", start=0.0, dur=4.0, chapter="01 · 测试",
               text="金帧确定性自检", sub="金帧确定性", big="金帧确定性")
+    # v1.0.1：剧本必须显式给设计（内置风格表已删，没有"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)
@@ -1350,18 +1439,23 @@ def t_web_style_payload():
         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"}]}
+    # v1.0.1：没有 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():
@@ -1407,6 +1501,632 @@ def t_golden_frames():
         status or "-", p.returncode, (d.get("reason") or "")[:120])
 
 
+# ============================================================================
+# v0.9：场景语法 + 视觉语言
+# ============================================================================
+
+def _load_grammar():
+    """加载 grammar.py（纯标准库）。找不到返回 None —— CI 里可能只拷了 scripts/ 的一部分。"""
+    try:
+        import grammar
+        return grammar
+    except Exception:                                       # noqa: BLE001
+        cand = os.path.join(HERE, "grammar.py")
+        if not os.path.exists(cand):
+            return None
+        import importlib.util
+        spec = importlib.util.spec_from_file_location("sc_grammar", cand)
+        mod = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(mod)
+        return mod
+
+
+def _fake_scenes(G, lines, per=6.0):
+    """按固定时长造 timeline 段（不跑 TTS），只用来测选型。"""
+    scenes, t = [], 0.0
+    for ln in lines:
+        row = dict(ln, start=round(t, 3), end=round(t + per, 3), dur=round(per, 3))
+        scenes.append(row)
+        t += per
+    return scenes
+
+
+def t_scene_grammar():
+    """52 场景语法：10 类都能被选中、选型确定、段长门会降级。
+
+    为什么要有这条：v0.9 之前 quote/emphasis/calm 三种 kind 全部落到 body 绘制器，
+    画面永远只有一套骨架。这条断言盯的是"内容 -> 构图"这条链路真的在分流，
+    而不是"代码里写了 10 个函数但没人调用"。
+    """
+    G = _load_grammar()
+    if G is None:
+        return "skip（没有 grammar.py）"
+    lines = [
+        {"id": "a", "kind": "hook", "chapter": "01", "text": "开场一句。", "big": "开场"},
+        {"id": "b", "kind": "body", "chapter": "02", "text": "我们每天被打断 47 次。", "big": "47 次"},
+        {"id": "c", "kind": "body", "chapter": "02", "text": "对比一下：深度工作四小时，产出是碎片时间的三倍。",
+         "big": "四小时 vs 碎片", "items": [{"text": "深度工作"}, {"text": "碎片时间"}]},
+        {"id": "d", "kind": "body", "chapter": "03", "text": "第一步清空收件箱，然后关掉通知，接着单线程，最后复盘。",
+         "big": "四步", "items": [{"text": "清空"}, {"text": "关通知"}, {"text": "单线程"}, {"text": "复盘"}]},
+        {"id": "e", "kind": "quote", "chapter": "03", "text": "他说：「深度工作稀缺。」", "quote": "深度工作稀缺"},
+        {"id": "f", "kind": "body", "chapter": "04", "text": "各行业占比差异明显。", "big": "各行业占比",
+         "items": [{"text": "A 62%"}, {"text": "B 51%"}, {"text": "C 38%"}]},
+        {"id": "g", "kind": "body", "chapter": "05", "text": "注意力是换来的。", "big": "注意力是换来的"},
+        {"id": "h", "kind": "body", "chapter": "06", "text": "第五章开始了。", "big": "第五章"},
+        {"id": "i", "kind": "body", "chapter": "06", "text": "这里有五条要点要讲清楚。", "big": "五条要点",
+         "items": [{"text": "一"}, {"text": "二"}, {"text": "三"}, {"text": "四"}, {"text": "五"}]},
+        {"id": "j", "kind": "outro", "chapter": "99", "text": "开始就好。", "big": "开始就好"},
+    ]
+    scenes = _fake_scenes(G, lines)
+    plan = {"chapter_layout": {}, "layout_default": "left-stack", "style": "tech-deep"}
+    sb1 = G.plan_scenes([dict(s) for s in scenes], {"title": "t"}, plan)
+    got = [r["type"] for r in sb1["scenes"]]
+    # ① 确定性：同一份输入两次结果完全一致（含变体号与理由）
+    sb2 = G.plan_scenes([dict(s) for s in scenes], {"title": "t"}, plan)
+    assert [r["type"] for r in sb2["scenes"]] == got, "同一份稿子两次选型不同（不确定性）"
+    assert [r["variant"] for r in sb2["scenes"]] == [r["variant"] for r in sb1["scenes"]], \
+        "同一份稿子两次变体不同（不确定性）"
+    # ② 分流：至少命中 5 种不同类型（不是全退化成 list/statement）
+    assert len(set(got)) >= 5, "10 段只分出 %d 种构图（%r）：选型逻辑没在分流" % (len(set(got)), got)
+    assert "stat" in got and "compare" in got and "quote" in got, \
+        "数字/对比/引语三种特征没有各自分流：%r" % (got,)
+    # ③ 段长门：把 chart 塞进 2 秒段必须降级，且理由里写明
+    short = [{"id": "x", "kind": "body", "chapter": "01", "text": "短。", "big": "短",
+              "type": "chart", "series": [{"label": "A", "value": 1}]}]
+    sb3 = G.plan_scenes([dict(s) for s in _fake_scenes(G, short, per=2.0)],
+                        {"title": "t"}, plan)
+    r3 = sb3["scenes"][0]
+    assert r3["type"] != "chart", "2 秒的段仍选了 chart（段长门失效）"
+    assert any("降级" in x or "排除" in x for x in r3["reason"]), \
+        "降级没有留下理由：%r" % (r3["reason"],)
+    # ④ 显式 type 优先
+    ex = [{"id": "y", "kind": "body", "chapter": "01", "text": "随便一句", "big": "随便",
+           "type": "hero"}]
+    sb4 = G.plan_scenes([dict(s) for s in _fake_scenes(G, ex)], {"title": "t"}, plan)
+    assert sb4["scenes"][0]["type"] == "hero", "显式 type=hero 没生效：%r" % (sb4["scenes"][0],)
+    return "10 段 -> %d 种构图；降级 chart->%s；显式 type 生效" % (len(set(got)), r3["type"])
+
+
+def t_visual_languages():
+    """53 视觉语言包：8 套结构签名齐全、过体检、且彼此不是同一套。
+
+    为什么要有这条：v0.5 的"风格"只改配色，8 套风格骨架完全一样（用户抱怨的根因）。
+    这条盯的是"结构签名真的存在且互不相同"——母题/转场/重心偏移任一维度相同不算问题，
+    但**五组签名全同**就说明这套语言只是复制粘贴。
+    """
+    import designkit as DK
+    import stylekit as ST
+    # v1.0.1：没有 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())))
+        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[: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():
+    """54 场景类型只有一份"真值集合"：4 处定义必须集合相等（顺序可以不同）。
+
+    为什么比集合不比顺序：grammar.SCENE_TYPES 的顺序是"平手取位顺序"，改它会改变同一份
+    稿子的选型结果，所以它有独立语义；filmcheck/schema/scenes 只关心"有哪些类型"。
+    顺序不同是设计，集合不同是 bug（写错一个字母 = 某个类型永远画不出来）。
+    """
+    G = _load_grammar()
+    if G is None:
+        return "skip（没有 grammar.py）"
+    here_scripts = HERE
+    got = {"grammar": set(G.SCENE_TYPES)}
+    # filmcheck.SCENE_TYPES
+    try:
+        import filmcheck as FC
+        got["filmcheck"] = set(FC.SCENE_TYPES)
+    except Exception:                                       # noqa: BLE001
+        pass
+    # assets/scenes.py 的 _DRAWERS 键
+    mod = _load_scenes_mod()
+    if mod is not None and hasattr(mod, "_DRAWERS"):
+        got["scenes"] = set(mod._DRAWERS.keys())
+    # schema 的 enum
+    schema = os.path.join(os.path.dirname(os.path.dirname(here_scripts)),
+                          "..", "..", "schemas", "film.schema.json")
+    schema = os.path.normpath(schema)
+    if os.path.exists(schema):
+        try:
+            data = json.load(open(schema, encoding="utf-8"))
+            enum = (data["properties"]["lines"]["items"]["properties"]["type"]["enum"])
+            got["schema"] = set(enum)
+        except Exception:                                   # noqa: BLE001
+            pass
+    if len(got) < 3:
+        return "skip（只找到 %d 处真值：%s）" % (len(got), sorted(got))
+    base_name, base = sorted(got.items())[0]
+    for name, s in got.items():
+        if s != base:
+            raise AssertionError("场景类型集合不一致：%s 与 %s 差 %r / %r"
+                                 % (name, base_name, sorted(s - base), sorted(base - s)))
+    return "%d 处真值集合一致（%d 类）：%s" % (len(got), len(base), "/".join(sorted(got)))
+
+
+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)))
+    tool = os.path.join(root, "tools", "silhouette_qa.py")
+    if not os.path.exists(tool):
+        return "skip（没有 tools/silhouette_qa.py）"
+    p = subprocess.run([sys.executable, tool, "--json"],
+                       capture_output=True, text=True, encoding="utf-8", errors="replace",
+                       cwd=root)
+    out = (p.stdout or "").strip()
+    i = out.find("{")
+    if i < 0:
+        return "skip（silhouette_qa 没输出 JSON：%s）" % ((p.stderr or out) or "")[:120]
+    try:
+        d = json.loads(out[i:])
+    except json.JSONDecodeError as e:
+        return "skip（silhouette_qa JSON 解析失败：%s）" % e
+    pairs = d.get("pairs") or []
+    # 三档语义与工具对齐：status 只有 pass / fail / skip 三种。
+    # 只认 returncode 会把"工具没渲出帧"（skip）也记成 PASS —— 那正是本仓库反复踩的坑。
+    failed = [x for x in pairs if str(x.get("status")) == "fail"]
+    skipped = [x for x in pairs if str(x.get("status")) == "skip"]
+    if p.returncode != 0 or failed:
+        names = ["%s×%s" % (x.get("a"), x.get("b")) for x in failed[:4]]
+        raise AssertionError("剪影不可区分：%d/%d 对失败（%s）；换风格仍只是换色"
+                             % (len(failed), len(pairs), ", ".join(names)))
+    if skipped:
+        return "skip（%d/%d 对没渲出来：%s）" % (
+            len(skipped), len(pairs),
+            ", ".join("%s×%s" % (x.get("a"), x.get("b")) for x in skipped[:3]))
+    # 同明暗族是"保守下界"：跨族很多时候靠 ΔB（背景亮度差）就能过，那不是构图证据。
+    # 所以这条断言在报告里必须把同族数字单独说出来，别让 28/28 被读成"8 套风格结构全不同"。
+    same = ((d.get("summary") or {}).get("by_family") or {}).get("same") or {}
+    same_n = same.get("pairs")
+    same_ok = same.get("pass")
+    if same_n and same_ok is not None and int(same_ok) < int(same_n):
+        raise AssertionError("同明暗族只有 %s/%s 对可区分（保守下界不达标）"
+                             % (same_ok, same_n))
+    return "%d 对全部可区分（同明暗族 %s/%s，保守下界也过）" % (
+        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 失效）"
+    # v1.0.1 起语义反转：**不给 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 零模板：仓库里**不许再有**预设/模板文件（v1.0.1 起本技能只提供技术，不提供模板）。
+
+    反过来断言：早先这条是"presets/*.json 可读可转"，v1.0.1 把预设整个删掉后，
+    如果只是删掉这条检查，就再也拦不住"哪天有人又加一套预设进去"。
+    所以改成**禁止存在**——删掉模板是一次性动作，守住它是长期契约。
+    """
+    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, ("v1.0.1 起本技能不提供模板，这些必须删掉：%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 里的要求必须真的生效（自然语言 -> 约束 -> 采样结果）。
+
+    这条防的是**需求被静默吃掉**：v1.0.1 之前 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 就报"找不到设计"（v1.0.1 实测踩到：
+    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 字幕样式可定制（v1.0.2）：design.visual.subtitle 必须真的改变像素，缺省逐像素不变。
+
+    为什么必须有这条：字幕字号/位置/背板过去是 filmkit 的**模块常量**，任何两条片子
+    的字幕带都一模一样 —— 这正是用户说的"跨片大面积重复"。改成设计字段后，最容易
+    出现的退化是"字段读进来了但没传给 draw_subtitle"（写完不生效，实测踩过）。
+    所以这里验行为：同一个 theme、同一段文字，换字幕参数必须像素不同；
+    不传参数时必须与 v1.0.1 的调用逐像素一致（老项目不漂）。
+    """
+    import numpy as _np
+    import designkit as DK
+    # 用一套现场采样设计里的主题，避免依赖内置主题表（v1.0.1 已删）
+    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 片内版式轮换（v1.0.2）：layout_cycle 真的让不同章节换骨架，同章必须稳定。
+
+    用户原则 5：同一部片不能"长时间一张版式"。v1.0.1 的 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 不许高概率直接失败（v1.0.2）。
+
+    实测过的真缺陷：配色候选去重按 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。
+
+    v1.0.1 删内置风格表时留下了一批**死路径**：stylekit 的 --list/--show NameError、
+    --lint 空表 exit 0（假绿）、filmkit 的 resolve_theme/style_plan 吞异常回落到写死的
+    v0.4 主题（静默降级 = 用模板出片）。这三种都必须绝迹。
+    """
+    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（v1.0.2）。
+
+    实测过的真缺陷：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 片间去重台账（v1.0.2）：确认过的设计要记住，下次提案主动避开；可关可查。
+
+    用户原则 5：不同视频的整体风格不能大面积重复。v1.0.1 只保证"同一 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 时长要求真的被接住（v1.0.2）：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；超范围拒绝"
 CASES = [
     ("1  TTS 缓存校验文本", t_cache_key),
     ("2  sub_window 覆盖长句", t_sub_window),
@@ -1459,6 +2179,22 @@ CASES = [
     ("49 TTS 后端可替换（接口契约）", t_tts_backend),
     ("50 web 风格载荷（legacy 必须回落）", t_web_style_payload),
     ("51 金帧回归（像素基线）", t_golden_frames),
+    ("52 场景语法（10 类分流/确定/段长门）", t_scene_grammar),
+    ("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),
 ]