minimal-agent 0.10.0 → 0.12.0

package/plugins/workflow-runner/test/ppt.load.test.ts

@@ -0,0 +1,1220 @@
+/**
+ * test/ppt.load.test.ts
+ * ------------------------------------------------------------
+ * 锁定 workflows/ppt.yaml（统一素材摄取 → 富化中间 material → 素材驱动版，与 webppt 并列的独立工作流）的
+ * 「可解析 + 关键骨架」：
+ *   - name=ppt（不是 webppt）、22 个顶层步、title 分母 /22
+ *   - inputs 含 topic(greedy 首位) + source（任意素材路径）+ style/mode/illustrations/out/image_intensity
+ *   - 摄取三步：stage_extract（抽文字+图片 + 图像统计）→ stage_vision_loop（for-each over readJson 逐图识图）
+ *     → stage_assemble_material（合并 material.md/json）
+ *   - 素材驱动：draft_from_material 以 user_request.md + material.md 为主干、design_doc 读 material.json（客户图按识图内容高权重 route=source/source-enhanced、必须全用）、
+ *     review 查客户图全用 + 识图对齐 + 配色协调、build 客户图 contain 不裁切 + 按朝向/重点区 + 客户图用尽闸门
+ *   - 所有 ${} 表达式可被引擎解析
+ *
+ * 定位法：packageRoot/workflows/ppt.yaml + parseWorkflowFile（ppt 与 webppt 是两个不同名工作流）。
+ */
+
+import { describe, expect, it } from 'bun:test';
+import { join } from 'node:path';
+
+import { evalExpr, interpolate } from '../src/expressions.js';
+import { parseWorkflowFile } from '../src/loader.js';
+import { VarStack } from '../src/types.js';
+import type { StepDef } from '../src/types.js';
+
+const pptPath = join(
+  import.meta.dir.replace(/[/\\]test$/, ''), // plugins/workflow-runner
+  '..', // plugins
+  '..', // 仓库根
+  'workflows',
+  'ppt.yaml',
+);
+
+describe('workflows/ppt.yaml（统一素材摄取·素材驱动）', () => {
+  it('解析通过且 name=ppt、25 步骨架正确', async () => {
+    const def = await parseWorkflowFile(pptPath);
+
+    expect(def.name).toBe('ppt'); // 与 webppt 区分，不撞名
+    expect(typeof def.description).toBe('string');
+
+    // inputs：topic(greedy 首位) + source 素材 + 高级覆盖项
+    const inputNames = (def.inputs ?? []).map((i) => i.name);
+    expect(inputNames).toEqual(
+      expect.arrayContaining(['topic', 'source', 'illustrations', 'style', 'mode', 'out', 'image_intensity']),
+    );
+    expect(inputNames[0]).toBe('topic');
+    expect((def.inputs ?? []).find((i) => i.name === 'topic')?.greedy).toBe(true);
+    const source = (def.inputs ?? []).find((i) => i.name === 'source');
+    expect(source?.default).toBe(''); // 可选，留空自动扫 cwd
+
+    // 22 个顶层步（含生成图语义复核、复核汇总与语义失败重试）+ title 分母 /22
+    const ids = def.steps.map((s) => s.id);
+    for (const id of [
+      'stage0_clarify',
+      'stage_extract',
+      'stage_vision_loop',
+      'stage_assemble_material',
+      'stage_draft_from_material',
+      'stage_draft_coverage',
+      'stage_draft_coverage_repair',
+      'stage_design_doc',
+      'stage_design_json_gate',
+      'stage_design_review',
+      'stage_design_recheck',
+      'stage_design_repair',
+      'stage_img_route_gate',
+      'stage_gen_images',
+      'stage_image_quality_gate',
+      'stage_generated_image_review',
+      'stage_generated_image_review_collect',
+      'stage_generated_image_retry',
+      'stage_build_loop',
+      'stage_visual_quality_gate',
+      'stage_export',
+      'verify_output',
+      'cleanup_intermediates',
+      'present_result',
+      'final_report',
+    ]) {
+      expect(ids).toContain(id);
+    }
+    expect(def.steps.length).toBe(25);
+    expect(ids.indexOf('cleanup_intermediates')).toBeLessThan(ids.indexOf('present_result'));
+    expect(ids.indexOf('present_result')).toBeLessThan(ids.indexOf('final_report'));
+    expect(ids.indexOf('stage_draft_from_material')).toBeLessThan(ids.indexOf('stage_draft_coverage'));
+    expect(ids.indexOf('stage_draft_coverage')).toBeLessThan(ids.indexOf('stage_draft_coverage_repair'));
+    expect(ids.indexOf('stage_draft_coverage_repair')).toBeLessThan(ids.indexOf('stage_design_doc'));
+    expect(ids.indexOf('stage_design_doc')).toBeLessThan(ids.indexOf('stage_design_json_gate'));
+    expect(ids.indexOf('stage_design_json_gate')).toBeLessThan(ids.indexOf('stage_img_route_gate'));
+    expect(ids.indexOf('stage_img_route_gate')).toBeLessThan(ids.indexOf('stage_build_loop'));
+    expect(ids.indexOf('stage_gen_images')).toBeLessThan(ids.indexOf('stage_build_loop'));
+    expect(ids.indexOf('stage_image_quality_gate')).toBeLessThan(ids.indexOf('stage_build_loop'));
+    for (const s of def.steps) {
+      expect(String(s.title)).toContain('/22');
+    }
+
+    // 收尾 echo；artifacts 只列最终交付物、不在被 rm 的 ./build 下
+    expect(def.steps.find((s) => s.id === 'final_report')?.type).toBe('echo');
+    const declared = def.artifacts ?? [];
+    expect(declared).toContain('./out/deck.pptx');
+    for (const a of declared) expect(a.startsWith('./build')).toBe(false);
+  });
+
+  it('stage0_clarify：样式推荐按配色感知、覆盖全部 13 个 VI（不再只露 6 个）', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const s0 = def.steps.find((s) => s.id === 'stage0_clarify');
+    const p = String(s0?.agent);
+    // 配色感知：显式要求把「行业/情绪/品牌色」映射到模板配色再推，没说偏好按行业惯例配色兜底
+    expect(p).toContain('配色');
+    expect(p).toContain('行业惯例配色');
+    expect(p).toMatch(/主色调|底色|色系/);
+    // 全部 13 个内置 VI 都进推荐菜单（此前只露 6 个：verdant/aegis/ember/amber/obsidian-xui/precision 不可见）
+    for (const vi of [
+      'aqua-glass',
+      'violet-meridian',
+      'ember-prism',
+      'amber-prism',
+      'verdant-grid',
+      'aegis-vector',
+      'comfort-vision',
+      'nebula-console',
+      'obsidian-xui',
+      'obsidian-optics',
+      'precision-horizon-dark',
+      'solar-relay',
+    ]) {
+      expect(p).toContain(vi);
+    }
+    // precision-horizon（浅色）独立成条，用全角冒号锁定、与 -dark 区分
+    expect(p).toContain('precision-horizon：');
+    // 指向共享技能目录的配色全表，供需要时深读
+    expect(p).toContain('视觉模板库');
+    // 「样式必问用户」红线 + AskUserQuestion 仍在
+    expect(p).toContain('AskUserQuestion');
+    expect(s0?.allowed_tools ?? []).toContain('AskUserQuestion');
+  });
+
+  it('stage_extract：抽取脚本 + 图像统计脚本，产 source_assets.json/source_stats.json，无素材不阻断', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const ex = def.steps.find((s) => s.id === 'stage_extract');
+    expect(ex).toBeTruthy();
+    const a = String(ex?.args?.command);
+    expect(ex?.tool).toBe('Bash');
+    expect(a).toContain('user_request.md'); // 早期固化用户目标
+    expect(a).toContain('resolve_source_input.py'); // 自然语言素材路径解析
+    expect(a).toContain('source_resolution.json'); // 解析报告
+    expect(a).toContain('PPT_SOURCE_REQUIRED_BUT_EMPTY'); // 明确素材缺失不伪装纯 topic
+    expect(a).toContain('extract_source_assets.py'); // 确定性抽取脚本
+    expect(a).toContain('image_stats.py'); // 图像统计脚本（image-stats skill）
+    expect(a).toContain('source_assets.json'); // base manifest
+    expect(a).toContain('source_stats.json'); // 统计产物
+    expect(a).toContain('${inputs.source}'); // 显式 source 优先
+    expect(a).toContain('--scan'); // 留空时扫 cwd
+    expect(ex?.onError).toBe('halt');
+    // 顺序：clarify → extract → vision → assemble → draft
+    const ids = def.steps.map((s) => s.id);
+    expect(ids.indexOf('stage_extract')).toBeGreaterThan(ids.indexOf('stage0_clarify'));
+    expect(ids.indexOf('stage_extract')).toBeLessThan(ids.indexOf('stage_vision_loop'));
+    expect(ids.indexOf('stage_vision_loop')).toBeLessThan(ids.indexOf('stage_assemble_material'));
+    expect(ids.indexOf('stage_assemble_material')).toBeLessThan(ids.indexOf('stage_draft_from_material'));
+  });
+
+  it('stage_vision_loop：for-each over readJson 遍历真实图片清单，逐图多模态识图写 vision json', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const loop = def.steps.find((s) => s.id === 'stage_vision_loop');
+    expect(loop?.type).toBe('loop');
+    // 用 asArray(readJson(...)) 取出运行时抽取的图片清单；缺字段/null → 0 轮，坏结构由 asArray 报错。
+    expect(String(loop?.over)).toContain('asArray');
+    expect(String(loop?.over)).toContain('readJson');
+    expect(String(loop?.over)).toContain('source_assets.json');
+    expect(String(loop?.over)).toContain('images');
+    expect(loop?.as).toBe('img');
+    expect(String(loop?.when)).toContain('source_assets.json'); // 无 manifest 不进
+    // 内层 vision_one：多模态 llm，images 引用当前 img.file；随后 Write 落盘
+    const dos = (loop?.do ?? []) as StepDef[];
+    const vone = dos.find((s) => s.id === 'vision_one');
+    expect(vone).toBeTruthy();
+    expect(Array.isArray(vone?.images)).toBe(true);
+    expect(String((vone?.images ?? []).join(','))).toContain('${img.file}'); // 喂当前图给模型
+    const va = String(vone?.llm);
+    expect(va).toContain('key_region'); // 重点区
+    expect(va).toContain('suitable_as_background'); // 是否宜做背景
+    // 2026-07-03：图表核心结论字段（治「图表寓意没被理解、配不上」）
+    expect(va).toContain('key_message');
+    expect(va).toContain('data_points');
+    // 2026-07-03：图上烧进画面的文字结构化记录（治「带字图直接图生图，字既没去掉也没被记下来重配」）
+    expect(va).toContain('embedded_text');
+    expect(va).toContain('region');
+    // 真机复盘：模型把文字写进 description 却漏填 embedded_text 结构化字段（key_message/data_points 都填了）
+    // ——2026-07-03 提升显著性，要求 description 提到的文字必须同步抄进 embedded_text。
+    expect(va).toContain('必填此字段');
+    expect(va).toContain('原样再抄一遍');
+    expect(vone?.onError).toBe('continue'); // 无多模态模型 / 单图失败不阻断
+    const write = dos.find((s) => s.id === 'write_vision_json');
+    expect(write?.tool).toBe('Write');
+    expect(String(write?.args?.file_path)).toContain('vision/${img.file}.json');
+    expect(String(write?.when)).toContain('length(vision_json)');
+  });
+
+  it('stage_draft_coverage(_repair)：原文主题覆盖检查 + fast/best 都跑的单次回填（2026-07-03）', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const check = def.steps.find((s) => s.id === 'stage_draft_coverage');
+    expect(check?.tool).toBe('Bash');
+    expect(String(check?.args?.command)).toContain('draft_coverage_check.py');
+    expect(check?.onError).toBe('continue');
+
+    const repair = def.steps.find((s) => s.id === 'stage_draft_coverage_repair');
+    expect(String(repair?.when)).toContain('draft_coverage_report.json');
+    expect(String(repair?.when)).toContain("readJson('./build/draft_coverage_report.json', 'ok') == false");
+    // 用户点名最高优先级问题：fast/best 都要跑，when 不能限死 quality=='best'。
+    expect(String(repair?.when)).not.toContain("quality == 'best'");
+    expect(String(repair?.agent)).toContain('draft_coverage_report.md');
+    expect(String(repair?.agent)).toContain('material.md');
+    expect(String(repair?.agent)).toContain('尽力而为的单次回填');
+    expect(repair?.onError).toBe('continue');
+    expect(repair?.max_retries).toBe(0);
+  });
+
+  it('2026-07-03 四页复盘：版式规划执行契约 + 背景前景禁同主体重复（第3/4页事故）', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const dos = def.steps.find((s) => s.id === 'stage_build_loop')?.do ?? [];
+    const batch = String(dos.find((s) => s.id === 'build_batch')?.agent);
+    // ① build_batch 客户图引用契约：contain 类图禁铺整页背景，且明示视觉门有确定性【版式违规】兜底
+    //   （src_6 识图明说"绝不能当背景"、规划判 direct_contain，build 仍铺成 .bg-img——prompt 拦不住，
+    //    真修在 source_usage_check --layout-intent-only 的可修档 ERROR，这里只是"写对省一轮"提示）。
+    expect(batch).toContain('版式违规');
+    expect(batch).toContain('绝不铺整页背景');
+    // ② build_batch 同主体禁重复推广到任意图源（背景驾驶舱+前景 3 张驾驶舱特写 = 第3页事故）。
+    expect(batch).toContain('前景禁止再排同主体图片卡');
+    // ③ design_doc 一页一主视觉规则。
+    const dd = String(def.steps.find((s) => s.id === 'stage_design_doc')?.agent);
+    expect(dd).toContain('背景前景禁同主体重复');
+    expect(dd).toContain('一页一主视觉');
+    // ④ design_review 罪状清单质问项。
+    const rv = String(def.steps.find((s) => s.id === 'stage_design_review')?.agent);
+    expect(rv).toContain('背景前景同主体重复核对');
+  });
+
+  it('2026-07-03 六页复盘：角标/标签强调色必须自带色块底（--arsenal-blue 系统性靠色事故）', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const dos = def.steps.find((s) => s.id === 'stage_build_loop')?.do ?? [];
+    const batch = String(dos.find((s) => s.id === 'build_batch')?.agent);
+    // build_batch 预防性规则：t-eyebrow/label 类强调色短文字不得裸色浮在不确定背景上。
+    expect(batch).toContain('角标/标签强调色文字必须自带色块底');
+    expect(batch).toContain('t-eyebrow');
+    expect(batch).toContain('bullet-row .label');
+    // design_review 罪状清单对应质问项。
+    const rv = String(def.steps.find((s) => s.id === 'stage_design_review')?.agent);
+    expect(rv).toContain('强调色角标/标签系统性靠色核对');
+  });
+
+  it('2026-07-04 真机复盘：split 左图右文页 .edit-scrim 渐变方向必须对齐文字栏（p3/p7 同根因事故）', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const buildDos = def.steps.find((s) => s.id === 'stage_build_loop')?.do ?? [];
+    // build_batch 预防性规则：写 scrim 前先看文字在哪一栏，不能照抄示例的「左不透明右透明」方向。
+    const batch = String(buildDos.find((s) => s.id === 'build_batch')?.agent);
+    expect(batch).toContain('渐变方向必须对齐文字实际所在的栏');
+    expect(batch).toContain('镜像');
+    // visual_repair_batch 修复时的识别规则：整段正文压图不可读时先查渐变方向，别逐行打局部 scrim 补丁。
+    const gateDos = def.steps.find((s) => s.id === 'stage_visual_quality_gate')?.do ?? [];
+    const visualRepair = gateDos.find((s) => s.id === 'visual_repair_batch');
+    expect(String(visualRepair?.agent)).toContain('跟着文字栏镜像');
+    // 2026-07-05 复盘：镜像方向对了但字色没跟着换（深底深字）——scrim 深浅变体必须跟文字色绑定。
+    expect(batch).toContain('深浅 scrim 变体必须跟文字色绑定');
+    expect(batch).toContain('浅色 VI 模板（白底+深字，如 aegis-vector 系）优先选浅色磨砂镜像变体');
+  });
+
+  it('2026-07-05 真机复盘：.slide.section 章节引导页同样要镜像 scrim（p2/p5 同根因事故，上一版规则被误读成只对 split/two-col 生效）', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const buildDos = def.steps.find((s) => s.id === 'stage_build_loop')?.do ?? [];
+    const batch = String(buildDos.find((s) => s.id === 'build_batch')?.agent);
+    expect(batch).toContain('.slide.section');
+    expect(batch).toContain('唯一判据是文字所在的 `grid-column`，不是 class 名字');
+    const gateDos = def.steps.find((s) => s.id === 'stage_visual_quality_gate')?.do ?? [];
+    const visualRepair = String(gateDos.find((s) => s.id === 'visual_repair_batch')?.agent);
+    expect(visualRepair).toContain('.slide.section');
+    expect(visualRepair).toContain('判据只看文字实际的');
+  });
+
+  it('2026-07-05 真机复盘：图渐隐入纸感面板式 scrim 的不透明拐点必须早于文字栏起点（p4/p14 同根因，正文发糊但标题正常）', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const buildDos = def.steps.find((s) => s.id === 'stage_build_loop')?.do ?? [];
+    const batch = String(buildDos.find((s) => s.id === 'build_batch')?.agent);
+    expect(batch).toContain('图渐隐入纸感面板');
+    expect(batch).toContain('渐变必须在这个百分比之前就已经到达 ≥0.85 不透明度');
+    const gateDos = def.steps.find((s) => s.id === 'stage_visual_quality_gate')?.do ?? [];
+    const visualRepair = String(gateDos.find((s) => s.id === 'visual_repair_batch')?.agent);
+    expect(visualRepair).toContain('大概率不是方向错，是"图渐隐入纸感面板"式 scrim 的不透明拐点太晚');
+  });
+
+  it('2026-07-05 真机复盘：scrim 不透明区必须覆盖文字所在区域不分横竖轴（light-bottom 类页顶标题落空事故）', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const buildDos = def.steps.find((s) => s.id === 'stage_build_loop')?.do ?? [];
+    const batch = String(buildDos.find((s) => s.id === 'build_batch')?.agent);
+    expect(batch).toContain('不分横竖轴、不分具体 CSS 写法');
+    expect(batch).toContain('light-bottom');
+    const gateDos = def.steps.find((s) => s.id === 'stage_visual_quality_gate')?.do ?? [];
+    const visualRepair = String(gateDos.find((s) => s.id === 'visual_repair_batch')?.agent);
+    expect(visualRepair).toContain('若不可读的是 `.deck-header`/`.deck-title`');
+  });
+
+  it('2026-07-05 真机复盘：卡内文字禁用 margin-top:auto 等边缘对齐撑出空心大卡（四重防线安全矩阵页事故）', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const buildDos = def.steps.find((s) => s.id === 'stage_build_loop')?.do ?? [];
+    const batch = String(buildDos.find((s) => s.id === 'build_batch')?.agent);
+    expect(batch).toContain('margin-top:auto');
+    expect(batch).toContain('align-self:flex-end');
+    expect(batch).toContain('四重防线安全矩阵页实测事故');
+  });
+
+  it('2026-07-05 真机复盘：内容块 auto 高度浮在 1fr body 行顶部导致下半页整页留白（链式价值页事故）', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const buildDos = def.steps.find((s) => s.id === 'stage_build_loop')?.do ?? [];
+    const batch = String(buildDos.find((s) => s.id === 'build_batch')?.agent);
+    expect(batch).toContain('grid-template-rows:auto 1fr');
+    expect(batch).toContain('链式价值');
+    expect(batch).toContain('不能让一组内容卡浮在页面上方、下半页整页留白');
+  });
+
+  it('2026-07-05 真机复盘：超大号单行标题渲染宽度超出共享 scrim 固定拐点百分比（p3「一次代价高昂的质量事故」事故）', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const buildDos = def.steps.find((s) => s.id === 'stage_build_loop')?.do ?? [];
+    const batch = String(buildDos.find((s) => s.id === 'build_batch')?.agent);
+    expect(batch).toContain('scrim-left-dark');
+    expect(batch).toContain('字符数 × 字号');
+    expect(batch).toContain('方向和拐点位置都对');
+  });
+
+  it('2026-07-05 真机复盘：SVG柱状图短柱塞不下自己的内嵌标签导致溢出侵入邻柱（p10成本条形图事故）', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const buildDos = def.steps.find((s) => s.id === 'stage_build_loop')?.do ?? [];
+    const batch = String(buildDos.find((s) => s.id === 'build_batch')?.agent);
+    expect(batch).toContain('查看基础·4–5千');
+    expect(batch).toContain('画在柱子**外侧**');
+  });
+
+  it('2026-07-05 真机复盘：align-self:center撑爆画布把标题挤出可见区域（p6五大暗角事故）', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const buildDos = def.steps.find((s) => s.id === 'stage_build_loop')?.do ?? [];
+    const batch = String(buildDos.find((s) => s.id === 'build_batch')?.agent);
+    expect(batch).toContain('比溢出到底部更隐蔽更严重');
+    expect(batch).toContain('bullet-strip');
+  });
+
+  it('2026-07-05 真机复盘：径向图表外围标签延伸方向超出viewBox边界被裁切（p6五角图事故）', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const buildDos = def.steps.find((s) => s.id === 'stage_build_loop')?.do ?? [];
+    const batch = String(buildDos.find((s) => s.id === 'build_batch')?.agent);
+    expect(batch).toContain('时间碎片');
+    expect(batch).toContain('viewBox="0 0 600 600"');
+    expect(batch).toContain('text-anchor:start');
+  });
+
+  it('2026-07-05 真机复盘：图+说明卡片行不能各自独立占用同一 grid-column/grid-row（第8页74~78%重叠事故）', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const buildDos = def.steps.find((s) => s.id === 'stage_build_loop')?.do ?? [];
+    const batch = String(buildDos.find((s) => s.id === 'build_batch')?.agent);
+    expect(batch).toContain('图片和它下方的说明卡片被写成两个独立');
+    expect(batch).toContain('包进同一个 `<div style="grid-column:1/2;grid-row:2/3;display:flex;flex-direction:column">`');
+    const gateDos = def.steps.find((s) => s.id === 'stage_visual_quality_gate')?.do ?? [];
+    const visualRepair = String(gateDos.find((s) => s.id === 'visual_repair_batch')?.agent);
+    expect(visualRepair).toContain('一张图」和「其下方说明卡片行」且重叠占比 >70%');
+  });
+
+  it('2026-07-05 真机复盘：.fig-contain/.fig-fill 禁止内联 aspect-ratio（第6/8页事故，撑爆1fr轨道致catastrophic硬halt）', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const buildDos = def.steps.find((s) => s.id === 'stage_build_loop')?.do ?? [];
+    const batch = String(buildDos.find((s) => s.id === 'build_batch')?.agent);
+    expect(batch).toContain('这次是 `.fig-contain` 共享组件被内联 `aspect-ratio` 覆盖');
+    expect(batch).toContain('任何 `.fig-contain`/`.fig-fill` 组件都不准在内联 style 里加 `aspect-ratio`');
+    const gateDos = def.steps.find((s) => s.id === 'stage_visual_quality_gate')?.do ?? [];
+    const visualRepair = String(gateDos.find((s) => s.id === 'visual_repair_batch')?.agent);
+    expect(visualRepair).toContain('即使文字前缀写的是"WARNING"也必须排进本批最优先修');
+    expect(visualRepair).toContain('删掉这个内联 `aspect-ratio`');
+  });
+
+  it('2026-07-05 真机复盘：水平柱图满刻度柱的数值标签需画在柱内且换高对比色（ROI页事故，标签色=柱色致对比度1.00）', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const buildDos = def.steps.find((s) => s.id === 'stage_build_loop')?.do ?? [];
+    const batch = String(buildDos.find((s) => s.id === 'build_batch')?.agent);
+    expect(batch).toContain('柱长 ≥ 绘图区宽度 90%');
+    expect(batch).toContain('柱内部靠右');
+    const gateDos = def.steps.find((s) => s.id === 'stage_visual_quality_gate')?.do ?? [];
+    const visualRepair = String(gateDos.find((s) => s.id === 'visual_repair_batch')?.agent);
+    expect(visualRepair).toContain('柱长≥绘图区 90% 时标签必须画在柱内靠右');
+  });
+
+  it('2026-07-05 真机复盘：image_weight≈0 的 data-visual/list/metric 页不得用近纯白整页 scrim 盖死 AI 背景图（13页deck 4页同时中招，图形同虚设）', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const buildDos = def.steps.find((s) => s.id === 'stage_build_loop')?.do ?? [];
+    const batch = String(buildDos.find((s) => s.id === 'build_batch')?.agent);
+    expect(batch).toContain('image_weight` 判定接近 0 的 data-visual/list/metric 结构页');
+    expect(batch).toContain('不得超过约 0.6');
+    const gateDos = def.steps.find((s) => s.id === 'stage_visual_quality_gate')?.do ?? [];
+    const visualRepair = String(gateDos.find((s) => s.id === 'visual_repair_batch')?.agent);
+    expect(visualRepair).toContain('AI 背景图被 scrim 盖到不可辨识');
+  });
+
+  it('2026-07-06 真机复盘：圆形徽标（.ring-label/.step-num）塞长文本会溢出圆外与邻近内容重叠，需改胶囊/矩形（N周→N小时、6–12月两页同时中招）', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const buildDos = def.steps.find((s) => s.id === 'stage_build_loop')?.do ?? [];
+    const batch = String(buildDos.find((s) => s.id === 'build_batch')?.agent);
+    expect(batch).toContain('圆形徽标/环形进度条内嵌文字');
+    expect(batch).toContain('横向胶囊/矩形标签');
+    const gateDos = def.steps.find((s) => s.id === 'stage_visual_quality_gate')?.do ?? [];
+    const visualRepair = String(gateDos.find((s) => s.id === 'visual_repair_batch')?.agent);
+    expect(visualRepair).toContain('圆形徽标塞长文本溢出');
+  });
+
+  it('2026-07-06 真机复盘：build_batch 绝不能编辑 img_plan.json（阶段7生图已跑完，事后加条目不会真的生成，留下幽灵引用致source_usage_check硬门halt整个-p进程）', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const buildDos = def.steps.find((s) => s.id === 'stage_build_loop')?.do ?? [];
+    const batch = String(buildDos.find((s) => s.id === 'build_batch')?.agent);
+    expect(batch).toContain('绝不修改 `img_plan.json`');
+    expect(batch).toContain('`img_plan.json` 只能由阶段 7 之前的确定性脚本步骤写');
+  });
+
+  it('2026-07-05 真机复盘：内容页 deck-header 叠在 AI 照片背景上同样要对比度保护，不止封面/章节（p5 三大盲区标题实测对比度1.00事故）', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const buildDos = def.steps.find((s) => s.id === 'stage_build_loop')?.do ?? [];
+    const batch = String(buildDos.find((s) => s.id === 'build_batch')?.agent);
+    expect(batch).toContain('同一条铁律对所有内容页同样生效，不止封面/章节');
+    expect(batch).toContain('像素实测最差对比度 1.00，标题实质不可读');
+  });
+
+  it('2026-07-05 真机复盘：.brand-mark 角标改色治标不治本，必须照抄 .t-eyebrow 加背景色块（本轮已改深色仍8处对比度1.00事故）', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const gateDos = def.steps.find((s) => s.id === 'stage_visual_quality_gate')?.do ?? [];
+    const visualRepair = String(gateDos.find((s) => s.id === 'visual_repair_batch')?.agent);
+    expect(visualRepair).toContain('.brand-mark');
+    expect(visualRepair).toContain('纯改文字颜色治标不治本');
+  });
+
+  it('2026-07-05 真机复盘：过小字体共享同一错误数值时repair要一次性批量替换，不逐条改（10处font-size:22px事故）', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const gateDos = def.steps.find((s) => s.id === 'stage_visual_quality_gate')?.do ?? [];
+    const visualRepair = String(gateDos.find((s) => s.id === 'visual_repair_batch')?.agent);
+    expect(visualRepair).toContain('共享同一数值 font-size:Npx');
+    expect(visualRepair).toContain('批量把这个错误数值');
+  });
+
+  it('2026-07-05 真机复盘：route=source-enhanced页不适用ai_p<page>.png约定名(7页事故,阶段9对这类页永不生成该文件)', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const buildDos = def.steps.find((s) => s.id === 'stage_build_loop')?.do ?? [];
+    const batch = String(buildDos.find((s) => s.id === 'build_batch')?.agent);
+    expect(batch).toContain('绝不适用上面②这条约定名规则');
+    expect(batch).toContain('直接留空即可');
+    const gateDos = def.steps.find((s) => s.id === 'stage_visual_quality_gate')?.do ?? [];
+    const visualRepair = String(gateDos.find((s) => s.id === 'visual_repair_batch')?.agent);
+    expect(visualRepair).toContain('永远不会存在');
+    expect(visualRepair).toContain('绝不改猜其它文件名重试');
+  });
+
+  it('2026-07-05 真机复盘：给深底文字转白别靠text-white单类工具类,可能被更高特异性选择器覆盖(5页slide.section章节页事故)', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const buildDos = def.steps.find((s) => s.id === 'stage_build_loop')?.do ?? [];
+    const batch = String(buildDos.find((s) => s.id === 'build_batch')?.agent);
+    expect(batch).toContain('特异性 (0,3,0)');
+    expect(batch).toContain('用内联 `style="color:#fff"`');
+    const gateDos = def.steps.find((s) => s.id === 'stage_visual_quality_gate')?.do ?? [];
+    const visualRepair = String(gateDos.find((s) => s.id === 'visual_repair_batch')?.agent);
+    expect(visualRepair).toContain('更高特异性的选择器');
+    expect(visualRepair).toContain('内联 `style="color:#fff"`');
+  });
+
+  it('stage_assemble_material：合并脚本产 material.md/json + 确定性客户图版式/图生图规划', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const am = def.steps.find((s) => s.id === 'stage_assemble_material');
+    const a = String(am?.args?.command);
+    expect(am?.tool).toBe('Bash');
+    expect(a).toContain('assemble_material.py');
+    expect(a).toContain('material.json');
+    expect(a).toContain('material.md');
+    // 紧接确定性规划脚本：逐图算定 usage_intent/是否图生图/模板/文字区 → source_layout_plan.json/md
+    expect(a).toContain('plan_source_layout.py');
+    expect(a).toContain('source_layout_plan');
+    expect(am?.onError).toBe('continue');
+  });
+
+  it('客户图图生图确定性化：规划→设计服从→兜底注入 img_plan，治「低清图硬铺/图生图没触发」根因', async () => {
+    const def = await parseWorkflowFile(pptPath);
+
+    // ① 摄取后跑确定性规划（在 design 之前，data 已齐）
+    const ids = def.steps.map((s) => s.id);
+    const am = def.steps.find((s) => s.id === 'stage_assemble_material');
+    expect(String(am?.args?.command)).toContain('plan_source_layout.py --build ./build');
+    expect(ids.indexOf('stage_assemble_material')).toBeLessThan(ids.indexOf('stage_design_doc'));
+
+    // ② 设计步「读规划、照它执行」——逐图心算被收成确定性
+    const dd = String(def.steps.find((s) => s.id === 'stage_design_doc')?.agent);
+    expect(dd).toContain('source_layout_plan'); // 读确定性规划
+    expect(dd).toContain('enhance_required'); // 服从「是否必须图生图」
+    expect(dd).toContain('enhance_prompt'); // 用算好的图生图提示词、别自己另写
+
+    // ③ 对抗评审逐张比对规划（确定性裁决）
+    const rv = String(def.steps.find((s) => s.id === 'stage_design_review')?.agent);
+    expect(rv).toContain('source_layout_plan');
+    expect(rv).toContain('enhance_required');
+
+    // ④ 生图前确定性兜底注入：必须图生图的客户图条目 union 进 img_plan（不靠设计步记得加）
+    const gate = def.steps.find((s) => s.id === 'stage_img_route_gate');
+    expect(gate?.tool).toBe('Bash');
+    expect(gate?.agent).toBeUndefined();
+    expect(gate?.maxTurns).toBeUndefined();
+    expect(String(gate?.when)).toContain('design_json_ok');
+    const ga = String(gate?.args?.command);
+    expect(ga).toContain('--ensure-img-plan');
+    expect(ga).toContain('plan_source_layout.py');
+    // 2026-07-05 真机 src_9 事故：design LLM 猜错客户图扩展名（真实 .png 猜成 .jpg）致图生图找不到
+    // 源文件、静默退化占位渐变图，真正生成好的正确扩展名条目却晾在一边没被引用——生图前必须先对齐
+    // source_assets.json 真实文件名，且顺序在 --ensure-img-plan 之后（先 union 齐再纠正）。
+    expect(ga).toContain('--reconcile-extensions');
+    expect(ga.indexOf('--ensure-img-plan')).toBeLessThan(ga.indexOf('--reconcile-extensions'));
+    // 本轮（真机第二轮）：AI 背景也确定性编进 img_plan（治「ai-* 从未进 img_plan、全退化平涂渐变」），不靠设计 LLM 记得写
+    expect(ga).toContain('--ensure-ai-img-plan');
+    // 第三轮（真机·治「route:none/html 页无底图→退化白底卡片墙」）：每页背景层确定性兜底
+    expect(ga).toContain('--ensure-page-backgrounds');
+    expect(ga).toContain('image_prompt_rewrite.py');
+    expect(ga).toContain('image_plan_lint.py');
+    expect(ga).toContain('touch ./build/img_route_ok');
+    // when 放宽：img_plan 存在 或 规划里有待增强图 —— 表达式可被引擎求值（不抛、不畸形）
+    const whenExpr = String(gate?.when);
+    expect(whenExpr).toContain('enhance_entries');
+    const vars = new VarStack();
+    expect(() => evalExpr(whenExpr, vars)).not.toThrow();
+
+    expect(ids.indexOf('stage_gen_images')).toBeLessThan(ids.indexOf('stage_build_loop'));
+    expect(String(def.steps.find((s) => s.id === 'stage_build_loop')?.when)).toContain('design_json_ok');
+  });
+
+  it('stage_draft_from_material：以 user_request.md + material.md 为内容主干，默认不联网', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const rs = def.steps.find((s) => s.id === 'stage_draft_from_material');
+    const a = String(rs?.agent);
+    expect(a).toContain('user_request.md'); // 用户目标最高权重
+    expect(a).toContain('material.md'); // 以它为主干
+    expect(a).toContain('主干');
+    expect(a).toContain('高权重');
+    expect(a).toContain('默认**不要调用联网检索工具**');
+    expect(String(rs?.allowed_tools ?? '')).not.toContain('WebSearch');
+    expect(String(rs?.allowed_tools ?? '')).not.toContain('WebFetch');
+    // 图表核心结论必须落进正文（2026-07-03，治「图配了但内容对不上」）
+    expect(a).toContain('图表核心结论');
+    expect(a).toContain('必须体现为某个论点或证据');
+  });
+
+  it('stage_design_doc：读 user_request/material，客户图 route=source/source-enhanced 必须全用、配色随图', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const dd = def.steps.find((s) => s.id === 'stage_design_doc');
+    const a = String(dd?.agent);
+    expect(a).toContain('user_request.md'); // 回看用户目标
+    expect(a).toContain('material.json'); // 富 manifest
+    expect(a).toContain('source-image-layout.md'); // 客户图布局铁律
+    expect(a).toContain('route');
+    expect(a).toContain('source'); // route=source
+    expect(a).toContain('source-enhanced'); // 图生图增强客户图
+    expect(a).toContain('image-to-image');
+    expect(a).toContain('enhanced_file');
+    expect(a).toContain('usage_intent'); // 图片用途先决策
+    expect(a).toContain('enhance_required'); // 新政策：所有客户图都图生图重绘（不再按低清门槛直接用）
+    expect(a).toContain('contain'); // dense-info 数据图 / 盲态原图保数据才 contain
+    expect(a).toContain('source_file'); // design.json 字段
+    expect(a).toContain('orient'); // 朝向驱动构图
+    expect(a).toContain('vision'); // 识图详述驱动配页
+    expect(a).toContain('stats'); // 统计驱动配色
+    expect(a).toContain('mode'); // img_plan 支持 text-to-image / image-to-image
+    expect(a).toContain('全部'); // 硬要求：客户图必须全用
+  });
+
+  it('stage_design_review：审查客户图全用 + 识图对齐 + 配色协调 + 全图生图cover填满', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const rv = def.steps.find((s) => s.id === 'stage_design_review');
+    const a = String(rv?.agent);
+    expect(a).toContain('user_request.md');
+    expect(a).toContain('material.json');
+    expect(a).toContain('客户素材利用'); // 评审子项
+    expect(a).toContain('全部'); // 必须全部用上
+    expect(a).toContain('cover 填满槽'); // 新政策：source-enhanced 一律 cover 填满（dense 才 contain）
+    expect(a).toContain('enhance_required=true'); // 所有客户图都应图生图重绘
+    expect(a).toContain('source-enhanced');
+    expect(a).toContain('image-to-image');
+    expect(a).toContain('低清原图');
+    expect(a).toContain('vision'); // 识图对齐
+    expect(rv?.allowed_tools).toContain('Edit'); // 当场修订
+  });
+
+  it('stage_design_review：非破坏性评审，合理留白不是错误，禁止为填满新增卡片/表格/浮动面板', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const rv = String(def.steps.find((s) => s.id === 'stage_design_review')?.agent);
+
+    expect(rv).toContain('非破坏性评审');
+    expect(rv).toContain('最高裁决顺序');
+    expect(rv).toContain('用户原始输入与 `build/user_request.md`');
+    expect(rv).toContain('Apple/DJI 式');
+    expect(rv).toContain('合理留白、大图背景、少量前景文案是合格目标');
+    expect(rv).toContain('内容预算只限制**文字过量/顶出画布**，不要求填满页面');
+    expect(rv).toContain('空白本身不是错误');
+    expect(rv).toContain('禁止为了填满页面新增卡片墙、表格墙、浮动白/灰面板');
+    expect(rv).toContain('禁止把影像叙事页改成文字列表页');
+    expect(rv).toContain('禁止把 Apple/DJI 式大图主视觉改成多块等权信息块');
+    expect(rv).toContain('拿不准就保留原设计');
+    expect(rv).toContain('不要为了填实而塞卡片/表格');
+    expect(rv).toContain('不要为了填满画布制造卡片');
+  });
+
+  it('build_batch：客户图全图生图 cover 填满 + dense contain + 按朝向/重点区 + 客户图用尽闸门', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const loop = def.steps.find((s) => s.id === 'stage_build_loop');
+    const dos = (loop?.do ?? []) as StepDef[];
+    const batch = dos.find((s) => s.id === 'build_batch');
+    const a = String(batch?.agent);
+    expect(a).toContain('source-image-layout.md'); // 动手前读规则
+    expect(a).toContain('object-fit:contain'); // dense-info 数据图保数据才 contain
+    expect(a).toContain('不留白裱框'); // 新政策：cover 填满、禁白裱框/letterbox
+    expect(a).toContain('orient'); // 按朝向排
+    expect(a).toContain('src_'); // 引用客户图 src_K.png
+    expect(a).toContain('enhanced_file'); // route=source-enhanced 引用增强图
+    expect(a).toContain('data-source-file'); // 保留原图映射
+    expect(a).toContain('display_role'); // 用途档位决定槽位大小（background/hero/evidence/gallery）
+    expect(a).toContain('enhanced_file');
+    expect(a).toContain('回退');
+    expect(a).toContain('material.json'); // 取识图/统计/重点区
+    const probe = dos.find((s) => s.id === 'build_probe');
+    expect(String(probe?.args?.command)).toContain('source_usage_check.py'); // 客户图用尽确定性闸门
+    expect(a).toContain('key_region'); // 文字避让 / 裁切对准重点
+    // 默认 cover 填满槽（图生图已重绘到槽比例）
+    expect(a).toContain('object-fit:cover');
+  });
+
+  it('ppt.yaml 默认不含联网检索工具，生图支持文生图和图生图，构图门关闭占空族', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const raw = JSON.stringify(def);
+    expect(raw).not.toContain('WebSearch');
+    expect(raw).not.toContain('WebFetch');
+
+    const qualityInput = def.inputs?.find((i) => i.name === 'quality');
+    expect(qualityInput?.default).toBe('fast');
+    const debugKeepBuild = def.inputs?.find((i) => i.name === 'debug_keep_build');
+    expect(debugKeepBuild?.type).toBe('enum');
+    expect(debugKeepBuild?.values).toEqual(['true', 'false']);
+    expect(debugKeepBuild?.default).toBe('true');
+
+    const routeGate = def.steps.find((s) => s.id === 'stage_img_route_gate');
+    expect(routeGate?.tool).toBe('Bash');
+    expect(routeGate?.agent).toBeUndefined();
+    expect(routeGate?.maxTurns).toBeUndefined();
+    expect(String(routeGate?.args?.command)).toContain('image_prompt_rewrite.py');
+    expect(String(routeGate?.args?.command)).toContain('image_plan_lint.py');
+    // 章节错位预警（张冠李戴，2026-07-02）：生图前跑 source_usage_check --design-only，
+    // WARNING 级恒 exit 0（|| true 双保险），绝不把模糊判定变成 halt。
+    expect(String(routeGate?.args?.command)).toContain('--design-only || true');
+
+    const ids = def.steps.map((s) => s.id);
+    expect(ids.indexOf('stage_img_route_gate')).toBeLessThan(ids.indexOf('stage_build_loop'));
+    expect(ids.indexOf('stage_gen_images')).toBeLessThan(ids.indexOf('stage_build_loop'));
+
+    const designReview = def.steps.find((s) => s.id === 'stage_design_review');
+    expect(String(designReview?.when)).toContain("inputs.quality == 'best'");
+
+    const designRepair = def.steps.find((s) => s.id === 'stage_design_repair');
+    expect(String(designRepair?.when)).toContain("inputs.quality == 'best'");
+
+    // 生图走专用 GenerateImage 工具（非 Bash）：无 120s 帽 + 内建降级，治「Bash 半途 SIGKILL」。
+    const gen = def.steps.find((s) => s.id === 'stage_gen_images');
+    expect(gen?.agent).toBeUndefined();
+    expect(gen?.tool).toBe('GenerateImage');
+    expect(gen?.tool).not.toBe('Bash');
+    expect(String(gen?.args?.plan)).toBe('./build/img_plan.json');
+    expect(String(gen?.args?.assets)).toBe('./build/assets');
+    expect(String(gen?.args?.timeout_ms)).toBe('300000');
+    expect(String(gen?.args?.wall_budget_ms)).toBe('3600000');
+    expect(gen?.onError).toBe('continue');
+
+    const quality = def.steps.find((s) => s.id === 'stage_image_quality_gate');
+    expect(quality?.tool).toBe('GenerateImage');
+    expect(String(quality?.when)).toContain('image_generation_report.json');
+    expect(String(quality?.args?.retry_degraded_report)).toBe('./build/image_generation_report.json');
+    expect(String(quality?.title)).toContain('fast一轮');
+    expect(quality?.args?.max_rounds).toBe(1);
+
+    // 生成图语义复核（LLM 识图）已屏蔽（2026-07-02 用户裁决：验证只走确定性脚本）——
+    // 三步 when:"false" 整体跳过，但骨架保留（defFingerprint 不变，旧断点可续跑）。
+    const imageReview = def.steps.find((s) => s.id === 'stage_generated_image_review');
+    expect(imageReview?.type).toBe('loop');
+    expect(String(imageReview?.when)).toBe('false');
+    expect(String(imageReview?.over)).toContain('img_plan.json');
+    expect(String(imageReview?.over)).toContain('asArray');
+    const reviewSteps = (imageReview?.do ?? []) as StepDef[];
+    const reviewOne = reviewSteps.find((s) => s.id === 'review_generated_image');
+    expect(String(reviewOne?.llm)).toContain('游戏手柄');
+    expect(String(reviewOne?.llm)).toContain('药瓶');
+    expect(String(reviewOne?.llm)).toContain('普通显示器');
+    expect(Array.isArray(reviewOne?.images)).toBe(true);
+    expect(reviewOne?.history_mode).toBe('isolated');
+    expect(Array.isArray(reviewOne?.context_files)).toBe(true);
+    expect(String(reviewOne?.allowed_tools)).toContain('Read');
+    expect(String(reviewOne?.llm)).toContain('章节序号');
+    expect(String(reviewOne?.llm)).toContain('1/2/3/4');
+    expect(String(reviewOne?.llm)).toContain('可编辑文字');
+
+    const imageCollect = def.steps.find((s) => s.id === 'stage_generated_image_review_collect');
+    expect(imageCollect?.tool).toBe('Bash');
+    expect(String(imageCollect?.when)).toBe('false');
+    expect(String(imageCollect?.args?.command)).toContain('generated_image_review_collect.py');
+
+    const imageRetry = def.steps.find((s) => s.id === 'stage_generated_image_retry');
+    expect(imageRetry?.tool).toBe('GenerateImage');
+    expect(String(imageRetry?.when)).toBe('false');
+    expect(String(imageRetry?.args?.retry_degraded_report)).toBe('./build/generated_image_semantic_retry_report.json');
+    expect(String(imageRetry?.args?.max_rounds)).toBe('3');
+
+    const visualGate = def.steps.find((s) => s.id === 'stage_visual_quality_gate');
+    expect(visualGate?.type).toBe('loop');
+    // 2026-07-02 裁决：视觉修复轮 3→2，且修复步开放 fast（上一轮 fast 41 个 ERROR 零修复直接放行）。
+    expect(visualGate?.max_iterations).toBe(2);
+    const visualSteps = (visualGate?.do ?? []) as StepDef[];
+    const visualCheck = visualSteps.find((s) => s.id === 'visual_quality_check');
+    expect(visualCheck?.tool).toBe('Bash');
+    expect(String(visualCheck?.args?.command)).toContain('visual_quality_gate.py');
+    expect(String(visualCheck?.args?.command)).toContain('--strict-product-detail');
+    const visualRepair = visualSteps.find((s) => s.id === 'visual_repair_batch');
+    expect(String(visualRepair?.when)).not.toContain("inputs.quality == 'best'");
+    expect(String(visualRepair?.agent)).toContain('前 3–5 个问题');
+    expect(String(visualRepair?.agent)).toContain('卡片墙');
+    expect(String(visualRepair?.agent)).toContain('背景图含不可编辑文字');
+    expect(String(visualRepair?.agent)).toContain('紧贴文字的小背板');
+    expect(String(visualRepair?.agent)).toContain('deck_visual_style_check.py');
+    expect(String(visualRepair?.agent)).toContain('文字溢出卡片');
+    // 2026-07-03 版式规划执行硬门：contain 类客户图被铺整页背景（第4页影子标题事故）→
+    // 视觉门【版式违规】ERROR 驱动修复，修复清单必须有对应修法条目。
+    expect(String(visualRepair?.agent)).toContain('版式违规');
+    expect(String(visualRepair?.agent)).toContain('direct_contain/gallery/small_evidence');
+    // 2026-07-03 真机六页复盘：27 处 ERROR 里 15+ 处共享同一 VI 强调色变量，逐条加 scrim 在 2 轮预算内
+    // 修不完——repair 必须优先识别归组提示、一次性改共享 CSS 规则。
+    expect(String(visualRepair?.agent)).toContain('共享同一文字颜色');
+    expect(String(visualRepair?.agent)).toContain('改一次共享 CSS 规则');
+    // 2026-07-02 截断续跑裁决：①「修到全量零 ERROR」无界指令收敛为批内有界（撞 maxTurns 20 的直接原因）；
+    // ② max_retries=2 启用引擎 maxTurns 截断续作（同 history 续跑，每次再给 20 轮），0 会把「可续跑」废掉。
+    expect(String(visualRepair?.agent)).not.toContain('只要还有 ERROR');
+    expect(String(visualRepair?.agent)).toContain('留给外层循环下一轮');
+    expect(visualRepair?.max_retries).toBe(2);
+    expect(visualRepair?.onError).toBe('continue');
+
+    const exp = def.steps.find((s) => s.id === 'stage_export');
+    expect(exp?.tool).toBe('Bash');
+    expect(exp?.agent).toBeUndefined();
+    expect(String(exp?.args?.command)).toContain('--no-occupancy');
+    expect(String(exp?.args?.command)).toContain('layout_balance: REPORT_ONLY');
+    expect(String(exp?.args?.command)).toContain('--require-existing-derived');
+    // 确定性兜底：缺失的 enhanced 派生图从原图拷顶上（防 deck 空框/死链）
+    expect(String(exp?.args?.command)).toContain('--reconcile-missing');
+    expect(String(exp?.args?.command)).toContain('source_usage_check.py');
+    // 减法（2026-07-02）：stage_export 不再重跑 deck_visual_style_check（与阶段18 视觉门
+    // 完全同参双跑、且视觉门达轮数已带残留放行）——style 检查唯一跑点在
+    // stage_visual_quality_gate（fast/best 统一 2 轮修复），导出只验哨兵。
+    expect(String(exp?.args?.command)).not.toContain('deck_visual_style_check.py');
+    expect(String(exp?.args?.command)).toContain('test -f ./build/visual_quality_ok');
+    expect(exp?.done_when).toBeUndefined();
+
+    const design = def.steps.find((s) => s.id === 'stage_design_doc');
+    const da = String(design?.agent);
+    expect(da).toContain('安装演示');
+    expect(da).toContain('产品外观');
+    expect(da).toContain('真实使用情境');
+    expect(da).toContain('柱状图');
+    expect(da).toContain('折线图');
+    expect(da).toContain('HTML/CSS/SVG');
+  });
+
+  it('内容预算确定性化 + 配图占满槽位 + 插图图层：治顶出/躲角/被遮挡', async () => {
+    const def = await parseWorkflowFile(pptPath);
+
+    // ① 设计评审前后都有确定性脚本检查；评审 agent 只读报告短修订，不再自己跑 Bash。
+    const precheck = def.steps.find((s) => s.id === 'stage_design_json_gate');
+    expect(precheck?.tool).toBe('Bash');
+    const pa = String(precheck?.args?.command);
+    expect(pa).toContain('normalize_design_json.py');
+    expect(pa).toContain('design_json_ok');
+    expect(pa).toContain('design_budget_check.py');
+    expect(pa).toContain('design_style_check.py');
+    expect(pa).toContain('design_review_checks.md');
+    expect(pa).toContain('design_review_checks.json');
+
+    const review = def.steps.find((s) => s.id === 'stage_design_review');
+    expect(String(review?.when)).toContain("inputs.quality == 'best'");
+    expect(review?.allowed_tools ?? []).not.toContain('Bash');
+    const ra = String(review?.agent);
+    expect(ra).toContain('design_review_checks.md');
+    expect(ra).toContain('只读预检报告');
+    expect(ra).toContain('不再自己跑脚本');
+
+    const recheck = def.steps.find((s) => s.id === 'stage_design_recheck');
+    expect(recheck?.tool).toBe('Bash');
+    const rca = String(recheck?.args?.command);
+    expect(rca).toContain("inputs.quality");
+    expect(rca).toContain('DESIGN_REVIEW_RECHECK_SKIPPED_FAST');
+    expect(rca).toContain('design_review_checks.json');
+    expect(rca).toContain('design_repair_residual.md');
+    expect(rca).toContain('design_budget_check.py');
+    expect(rca).toContain('design_style_check.py');
+    expect(rca).toContain('design_review_recheck.md');
+    expect(rca).toContain('design_review_recheck.json');
+
+    const repair = def.steps.find((s) => s.id === 'stage_design_repair');
+    expect(String(repair?.when)).toContain("inputs.quality == 'best'");
+    expect(String(repair?.when)).toContain('design_review_recheck.json');
+    expect(String(repair?.when)).toContain("'ok'");
+    expect(repair?.type).toBe('loop');
+    expect(repair?.max_iterations).toBe(3);
+    const repairSteps = (repair?.do ?? []) as StepDef[];
+    expect(String(repairSteps.find((s) => s.id === 'design_repair_hints')?.args?.command)).toContain('design_repair_hints.py');
+    const repairBatch = repairSteps.find((s) => s.id === 'design_repair_batch');
+    expect(String(repairBatch?.when)).toContain("inputs.quality == 'best'");
+    expect(String(repairBatch?.agent)).toContain('本批页面短修复');
+
+    // ② 设计步：预算会被确定性核对 + 目录/list 超预算默认双列 + source-enhanced aspect=槽位
+    const dd = String(def.steps.find((s) => s.id === 'stage_design_doc')?.agent);
+    expect(dd).toContain('design_budget_check.py'); // 第一版就按预算设计
+    expect(dd).toContain('双列');
+    expect(dd).toContain('槽位的比例'); // route=source-enhanced 的 aspect = 槽位比例（图生图重绘到槽位）
+
+    // ③ 构建步：图片必须填满槽位（治躲角/半填）+ 插图次顶层不被非文本遮挡
+    const loop = def.steps.find((s) => s.id === 'stage_build_loop');
+    expect(loop?.max_iterations).toBeLessThanOrEqual(6);
+    const dos = (loop?.do ?? []) as StepDef[];
+    const probe = dos.find((s) => s.id === 'build_probe');
+    expect(probe?.tool).toBe('Bash');
+    expect(String(probe?.args?.command)).toContain('deck_pages_check.py');
+    expect(String(probe?.args?.command)).toContain('source_usage_check.py');
+    expect(String(probe?.args?.command)).toContain('build_probe.json');
+    expect(String(probe?.args?.command)).toContain('build_complete');
+    const batchStep = dos.find((s) => s.id === 'build_batch');
+    expect(String(batchStep?.when)).toContain("!fileExists('./build/build_complete')");
+    expect(batchStep?.maxTurns).toBeLessThanOrEqual(24);
+    expect(batchStep?.max_retries).toBe(1);
+    const batch = String(batchStep?.agent);
+    expect(batch).toContain('build_probe.txt');
+    expect(batch).toContain('填满该单元'); // 占满槽位铁律
+    expect(batch).toContain('object-fit:contain');
+    expect(batch).toContain('object-position'); // cover 时按 key_region 填满裁边
+    expect(batch).toContain('次顶层'); // 插图图层：文本之下、背景之上
+    expect(batch).toContain('遮挡');
+    const done = dos.find((s) => s.id === 'build_done');
+    expect(String(done?.when)).toContain("fileExists('./build/build_complete')");
+  });
+
+  it('fast 链路清理旧运行哨兵，且说明/报告顺序为先生图后构建', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const desc = String(def.description);
+    expect(desc.indexOf('配图分流')).toBeLessThan(desc.indexOf('按设计文档**分批生成** HTML deck'));
+    expect(desc).toContain('默认 fast 每轮 ≤3 页');
+
+    const extract = def.steps.find((s) => s.id === 'stage_extract');
+    const cmd = String(extract?.args?.command);
+    for (const marker of [
+      'build_complete',
+      'layout_ok',
+      'visual_quality_ok',
+      'visual_quality_state.json',
+      'image_generation_report.json',
+      'generated_image_review.json',
+      'design_json_ok',
+      'design_json_gate.json',
+      'design.raw.json',
+      'export-summary.md',
+      'build_probe.json',
+    ]) {
+      expect(cmd).toContain(marker);
+    }
+    expect(cmd).toContain('rm -rf ./build/export ./build/generated-image-reviews');
+
+    const cleanup = def.steps.find((s) => s.id === 'cleanup_intermediates');
+    const cleanupCmd = String(cleanup?.args?.command);
+    expect(cleanupCmd).toContain('inputs.debug_keep_build');
+    expect(cleanupCmd).toContain('rm -rf ./build');
+    expect(cleanupCmd).toContain('debug_keep_build=true');
+    expect(cleanupCmd).not.toContain('[TEMP]');
+    expect(cleanupCmd).not.toContain('上线前');
+
+    const report = String(def.steps.find((s) => s.id === 'final_report')?.message);
+    expect(report.indexOf('配图分流')).toBeLessThan(report.indexOf('分批生成网页'));
+    expect(report).toContain('产品详情页视觉硬门');
+    expect(report).toContain('debug_keep_build=${inputs.debug_keep_build}');
+    expect(report).not.toContain('已在收尾清理——只保留最终 PPT');
+  });
+
+  it('标题跨页对齐约定 + 插图忠实落槽 + 标题长度（治导入PPT不齐/位置不对/超界，均 web 端）', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const loop = def.steps.find((s) => s.id === 'stage_build_loop');
+    const dos = (loop?.do ?? []) as StepDef[];
+    const batch = String(dos.find((s) => s.id === 'build_batch')?.agent);
+
+    // ① 统一 deck 头部约定：主标/副标同左对齐、跨页一致（治标题导入 PPT 不对齐）
+    expect(batch).toContain('deck-header');
+    expect(batch).toContain('deck-title');
+    expect(batch).toContain('deck-subtitle');
+    expect(batch).toContain('跨页对齐');
+
+    // ② 插图位置忠实于 design 指定槽位（治「位置不是设计的」）
+    expect(batch).toContain('design 指定的槽位');
+    expect(batch).toContain('位置忠实');
+
+    // ③ 设计步：内容页标题 ≤14 字 + 跨页对齐
+    const dd = String(def.steps.find((s) => s.id === 'stage_design_doc')?.agent);
+    expect(dd).toContain('≤14 字');
+    expect(dd).toContain('左对齐');
+  });
+
+  it('真机复盘重构：内容内边距不贴边 + 客户图≤1×不缩小 + 封面AI背景必出 + 卡内文字禁溢出 + 对抗评审质问式自证', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const loop = def.steps.find((s) => s.id === 'stage_build_loop');
+    const dos = (loop?.do ?? []) as StepDef[];
+    const batch = String(dos.find((s) => s.id === 'build_batch')?.agent);
+
+    // ① 统一内容内边距、标题不贴画布边；上下改 56/48 少吃竖向（治标题贴最左 + 给内容更多高度）
+    expect(batch).toContain('内容内边距');
+    expect(batch).toContain('padding:56px 112px 48px');
+    expect(batch).toContain('不贴画布边');
+
+    // ①b 结构性高度 bound（治反复出现的「内容超出下边缘」——slide 物理上溢不出）
+    expect(batch).toContain('结构性高度 bound');
+    expect(batch).toContain('min-height:0');
+    expect(batch).toContain('max-height:100%');
+    expect(batch).toContain('grid-template-rows:1fr 1fr');
+    // ①b-2 2026-07-05 真机复盘：grid-row 图片用 aspect-ratio 独立撑高、压穿下一行（第4页93%重叠事故）
+    expect(batch).toContain('aspect-ratio:21/9');
+    expect(batch).toContain('height:100%; min-height:0');
+
+    // ①c 背景层 = 逐字复用锁定骨架，🚫绝不渐变压图（治真机头号事故：兜底渐变盖死 AI 图）
+    expect(batch).toContain('绝不渐变压图');
+    expect(batch).toContain('锁定编辑式三层骨架');
+    expect(batch).toContain('--vi-fallback'); // 纯色兜底在底，图 cover 填满、不被渐变盖
+    expect(batch).toContain('禁自创'); // 禁自创无 grid 定义的 bespoke 布局类（治塌成空白页）
+
+    // ② 客户图尺寸/缩放铁律：display_role + ≤1× 不放大糊 + 最小占比不缩成角落小图
+    expect(batch).toContain('display_role');
+    expect(batch).toContain('max_upscale');
+    expect(batch).toContain('≤1×');
+    expect(batch).toContain('min_canvas_fraction');
+    expect(batch).toContain('绝不放大超过原生像素');
+
+    // ③ 卡内文字禁溢出 + 一行卡数随文长（治第 5/11/12 页窄卡长文重叠）
+    expect(batch).toContain('不溢出');
+    expect(batch).toContain('一行最多 3 卡');
+
+    // ④ design_doc：封面/章节/尾页 AI 背景从「可用」改「必出」（治封面空洞无背景）
+    const dd = String(def.steps.find((s) => s.id === 'stage_design_doc')?.agent);
+    expect(dd).toContain('必出');
+
+    // ⑤ ⭐ 对抗评审 = 质问式自证（预设有罪、逐条给证据、别自我表扬）—— 用户核心补充
+    const rv = String(def.steps.find((s) => s.id === 'stage_design_review')?.agent);
+    expect(rv).toContain('预设你有罪');
+    expect(rv).toContain('用事实自证');
+    expect(rv).toContain('自我表扬');
+    expect(rv).toContain('罪状');
+    // 铁律二：证据门控编辑——治「胆小 AI 把对的改错」过度修正（唯证据坐实才改、量不准默认保留）
+    expect(rv).toContain('把对的改错');
+    expect(rv).toContain('无依据的改动比漏判更糟');
+    expect(rv).toContain('证据坐实违规');
+    expect(rv).toContain('默认保留不动');
+    // 质问清单覆盖累积真实失败模式：标题贴左 / 客户图缩放 / 文字溢出重叠
+    expect(rv).toContain('贴到画布最左');
+    expect(rv).toContain('display_role');
+    expect(rv).toContain('重叠糊成一团');
+  });
+
+  it('编辑式融合转向：图做背景文字浮前景设为默认 + 出血背景分层 + padding 只束前景（治卡片墙主导、不像产品详情页）', async () => {
+    const def = await parseWorkflowFile(pptPath);
+
+    // ① design_doc：先定整页视觉策略、编辑式优先；引用 §2.2 产品详情页式融合库；点名「不靠表格/网格/悬浮卡片划分区域」
+    const dd = String(def.steps.find((s) => s.id === 'stage_design_doc')?.agent);
+    expect(dd).toContain('先定整页视觉策略');
+    expect(dd).toContain('§2.2 模板库'); // 引用编辑式模板库（§0 最高标准 + §2.2）
+    expect(dd).toContain('背景主导');
+    expect(dd).toContain('不靠表格/网格/悬浮卡片划分区域');
+
+    // ②（关键）编辑式融合页不算稀疏页、不受 ≤20% 硬帽——治「80% 被逼成卡片填满页」
+    expect(dd).toContain('编辑式融合页 ≠ 稀疏页');
+    expect(dd).toContain('不受下面 20% 限额约束');
+
+    // ③ render 决策重平衡：html+text 卡片不再是自动默认；产品/场景/能力优先图背景+前景文字
+    expect(dd).toContain('卡片不再是自动默认');
+    expect(dd).toContain('图作背景或半幅 hero、文字作前景浮层');
+
+    // ④ build_batch：编辑式三层分离（出血背景层 + scrim + 前景守边），内容页也可用
+    const loop = def.steps.find((s) => s.id === 'stage_build_loop');
+    const dos = (loop?.do ?? []) as StepDef[];
+    const batch = String(dos.find((s) => s.id === 'build_batch')?.agent);
+    expect(batch).toContain('编辑式融合分层');
+    expect(batch).toContain('edit-bg');
+    expect(batch).toContain('inset:0'); // 背景层出血、被 slide overflow:hidden 钳死
+    expect(batch).toContain('出血到画布边');
+    expect(batch).toContain('edit-scrim');
+    expect(batch).toContain('edit-content');
+    // 本轮：前景层禁卡墙网格（原「别把编辑式页拆成一堆悬浮卡片」强化为明确枚举 + 禁令）
+    expect(batch).toContain('禁卡片墙、禁网格划区、禁表格');
+    // 本轮（真机第二轮·治头号事故）：archetype 栅格落 .edit-content、绝不写在 .slide（否则两栏塌进左半、第二栏溢出被裁）
+    expect(batch).toContain('塌进左半');
+    expect(batch).toContain('.slide.X .edit-content');
+    // AI 底图按约定名 ai_p<page>.png 引用 + onerror 渐变兜底（内容页绝不只上 CSS 渐变 class 不放 img）
+    expect(batch).toContain('ai_p<page>.png');
+    expect(batch).toContain('ai_p<page>_fg.png');
+    expect(batch).toContain('背景专用');
+    expect(batch).toContain('ai-fallback');
+    // 图槽不再裱白卡/选项卡：图要么做整页底，要么 cover 满半幅，没有「小图浮白卡」中间态
+    expect(batch).toContain('没有「小图浮白卡」这种中间态');
+
+    // 第三轮（真机·治「半数内容页无背景→卡墙」）：背景层恒在、route 只决定前景；卡墙是没背景的下游症状
+    expect(batch).toContain('每个内容页 `.edit-bg` 必有背景图层');
+    expect(batch).toContain('`route` 只决定【前景怎么呈现】');
+    expect(batch).toContain('因为 route=html/none 就不给背景层'); // 明令禁止
+    // 现在每页都是编辑式三层页 → 「前景禁卡墙」对所有内容页生效（含 route=html/none 结构页）
+    expect(batch).toContain('每个内容页都有背景层、都是编辑式三层页');
+    expect(batch).toContain('磨砂文字垫'); // 只作文字背板、绝不是分区卡片
+    expect(batch).toContain('绝不是分区卡片');
+    // 透明抠图合流：cutout = 透明前景特写插图，绝不套白框（与去框铁律一致）
+    expect(batch).toContain('enhance_style=cutout');
+    expect(batch).toContain('透明特写插图');
+    expect(batch).toContain('background:transparent');
+    expect(batch).toContain('绝不套 `.src-figure` 白底/边框/padding');
+
+    // 本轮：统一字体 token + 结构图连线归属，防最后几页小字和孤立线条
+    expect(batch).toContain('--fs-hero');
+    expect(batch).toContain('--fs-axis');
+    expect(batch).toContain('字体 token');
+    expect(batch).toContain('diagram-node');
+    expect(batch).toContain('diagram-link');
+    expect(batch).toContain('diagram-label');
+
+    // ⑤（关键和谐）padding 只束前景文字层、背景层例外出血——不退化前轮「贴边/超下边缘」修复
+    expect(batch).toContain('图出血、字守边');
+    expect(batch).toContain('只针对前景内容/文字层');
+    // 前轮溢出修复断言仍在（共存、不回归）
+    expect(batch).toContain('padding:56px 112px 48px');
+    expect(batch).toContain('min-height:0');
+
+    // ⑥ 本轮（第二轮深化）：有底图→禁表格卡墙硬条件 + 表格降级图表优先 + 过载页混合处理
+    expect(dd).toContain('有底图就别再划区');
+    expect(dd).toContain('禁用表格');
+    expect(dd).toContain('禁用悬浮卡片墙');
+    expect(dd).toContain('字色随底图明暗自适应');
+    expect(dd).toContain('过载页按内容分流');
+    expect(dd).toContain('整合为一张 hero');
+    expect(dd).toContain('优先图表化'); // 数据/对比优先图表而非表格
+    expect(dd).toContain('表格是最后手段');
+
+    // ⑦ design_review 加罪状 🅵：有底图页是否仍表格/卡墙 + 过载页是否处理（服从 layout_constraint）
+    const review = String(def.steps.find((s) => s.id === 'stage_design_review')?.agent);
+    expect(review).toContain('🅵');
+    expect(review).toContain('有底图还在表格/卡墙划区');
+    expect(review).toContain('layout_constraint=fusion_no_cards');
+  });
+
+  it('产品详情页式硬字段：design.json 必须驱动构图而不是只靠 archetype/composition', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const dd = String(def.steps.find((s) => s.id === 'stage_design_doc')?.agent);
+    const review = String(def.steps.find((s) => s.id === 'stage_design_review')?.agent);
+    const loop = def.steps.find((s) => s.id === 'stage_build_loop');
+    const batch = String(((loop?.do ?? []) as StepDef[]).find((s) => s.id === 'build_batch')?.agent);
+
+    expect(dd).toContain('composition_style');
+    expect(dd).toContain('page_grammar');
+    expect(dd).toContain('one_sentence_takeaway');
+    expect(dd).toContain('visual_focus');
+    expect(dd).toContain('text_zone');
+    expect(dd).toContain('safe_text_zone');
+    expect(dd).toContain('visual_role');
+    expect(dd).toContain('primary_visual_type');
+    expect(dd).toContain('image_weight');
+    expect(dd).toContain('text_overlay_mode');
+    expect(dd).toContain('max_visible_words');
+    expect(dd).toContain('copy_budget');
+    expect(dd).toContain('main_visual_layer');
+    expect(dd).toContain('supporting_visual_layer');
+    expect(dd).toContain('text_overlay_zone');
+    expect(dd).toContain('visual_story');
+    expect(dd).toContain('semantic_image_prompt');
+    expect(dd).toContain('forbidden_layout');
+    expect(dd).toContain('visual_asset_contract');
+    expect(dd).toContain('背景和前景**不得使用同一张图片**');
+    expect(dd).toContain('ai_p<page>_fg.png');
+    expect(dd).toContain('背景/场景/hero 图零文字铁律');
+    expect(dd).toContain('章节序号');
+    expect(dd).toContain('HTML/SVG 可编辑前景层');
+    // 章节锚定配页（治张冠李戴，2026-07-02）：客户图按来源章节 section 锚定配页，语义契合只用于章节内挑页。
+    expect(dd).toContain('章节锚定配页');
+    expect(dd).toContain('张冠李戴');
+    expect(dd).toContain('图表核心结论必须呼应'); // stage_design_doc 自身的配图规则（2026-07-03）
+    // 图表结论呼应罪状（2026-07-03）：key_message 必须体现在该页 key_point/evidence 里，在 review 罪状清单。
+    expect(review).toContain('图表结论呼应核对');
+    expect(review).toContain('key_message');
+    // 原图文字重配（2026-07-03 src_6 事故：带字图 img2img 去字后，字的内容必须能在设计阶段判断是否重配）。
+    expect(dd).toContain('原图文字重配');
+    expect(dd).toContain('embedded_text');
+    expect(review).toContain('原图文字重配核对');
+    // 卡片自适应（末页 CTA 字骑出卡缘事故）：build_batch 禁固定宽高卡片 + 更宽文字/wrapper。
+    expect(batch).toContain('文字溢出卡片');
+    expect(batch).toContain('卡尺寸随内容自然撑开');
+    expect(dd).toContain('product-hero|feature-theater|detail-closeup|scenario-fullbleed|data-visual|gallery-strip|chapter-cinematic|quote-focus');
+    expect(dd).toContain('hero-scene|cinematic-feature|product-closeup|image-mosaic|spec-overlay|data-visual|before-after-scene');
+    expect(dd).toContain('DJI 式网格');
+    expect(dd).toContain('不要只靠 `archetype/composition`');
+
+    const precheck = String(def.steps.find((s) => s.id === 'stage_design_json_gate')?.args?.command);
+    const recheck = String(def.steps.find((s) => s.id === 'stage_design_recheck')?.args?.command);
+    expect(precheck).toContain('normalize_design_json.py');
+    expect(precheck).toContain('design_json_ok');
+    expect(precheck).toContain('design_style_check.py');
+    expect(precheck).toContain('DESIGN_REVIEW_PRECHECK_OK');
+    expect(recheck).toContain('normalize_design_json.py');
+    expect(recheck).toContain('design_style_check.py');
+    expect(recheck).toContain('DESIGN_REVIEW_RECHECK_OK');
+    expect(review).toContain('design_review_checks.md');
+
+    expect(batch).toContain('composition_style');
+    expect(batch).toContain('page_grammar');
+    expect(batch).toContain('image_weight');
+    expect(batch).toContain('main_visual_layer');
+    expect(batch).toContain('semantic_image_prompt');
+    expect(batch).toContain('forbidden_layout');
+    expect(batch).toContain('image-mosaic');
+    expect(batch).toContain('最多 5 页'); // 2026-07-02 提速：fast 每批 3→5 页
+    expect(batch).toContain('data-visual');
+    expect(batch).toContain('禁止大表格矩阵');
+    const visualGate = def.steps.find((s) => s.id === 'stage_visual_quality_gate');
+    const visualSteps = (visualGate?.do ?? []) as StepDef[];
+    expect(String(visualSteps.find((s) => s.id === 'visual_quality_check')?.args?.command)).toContain('visual_quality_gate.py');
+  });
+
+  it('编辑式最高标准·强制默认（第三轮·下沉到模板层）：每页背景层 + cards 罕见例外', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const dd = String(def.steps.find((s) => s.id === 'stage_design_doc')?.agent);
+    // 编辑式从「优先」升级为「强制默认」+ 每个内容页都有背景层（治无客户图页退回卡墙）
+    expect(dd).toContain('编辑式最高标准·强制默认');
+    expect(dd).toContain('每个内容页都必须有背景层');
+    expect(dd).toContain('AI 全幅底图'); // 无客户图时质量优先，渐变只作失败兜底
+    expect(dd).toContain('卡片墙 / 网格 / 表格 = 罕见例外');
+    // archetype 行标注 cards 降为罕见例外
+    expect(dd).toContain('`cards` 已降为罕见例外、默认别选');
+    // image_intensity 每页背景层底线
+    expect(dd).toContain('每个内容页都必须有背景层（★编辑式最高标准·治「白底卡海」）');
+    // 第三轮（真机·治「route:none 当『这页不要图』→白底卡墙」）：心智模型 + 内容页避免 route:none
+    expect(dd).toContain('背景层【永远有】');
+    expect(dd).toContain('【不决定有没有背景】');
+    expect(dd).toContain('内容页避免 `route:none`');
+    expect(dd).toContain('--ensure-page-backgrounds'); // 留空也会被确定性补氛围底图
+    const loop = def.steps.find((s) => s.id === 'stage_build_loop');
+    const buildBatch = String(((loop?.do ?? []) as StepDef[]).find((s) => s.id === 'build_batch')?.agent);
+    expect(buildBatch).toContain('所有 SVG 连线必须有语义归属');
+    expect(buildBatch).toContain('source-enhanced 图层必须服从');
+  });
+
+  it('第五轮·结构性根治：锁定骨架/AI背景默认/苹果式精炼/画像/size2k', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const dd = String(def.steps.find((s) => s.id === 'stage_design_doc')?.agent);
+    // 动笔前三问 + 苹果式精辟文案 + 识图×文案微调
+    expect(dd).toContain('动笔前三问');
+    expect(dd).toContain('MacBook Pro');
+    expect(dd).toContain('术语深度档');
+    expect(dd).toContain('识图×文案对应');
+    // AI 背景默认、渐变只作失败兜底（反转上轮 VI 渐变默认）
+    expect(dd).toContain('默认高清 AI 图，渐变只作失败兜底');
+    expect(dd).toContain('优先配高清 AI 全幅底图');
+    // stage0 画像参数化 + draft 按画像调深度
+    const s0 = String(def.steps.find((s) => s.id === 'stage0_clarify')?.agent);
+    expect(s0).toContain('术语深度档');
+    const draft = String(def.steps.find((s) => s.id === 'stage_draft_from_material')?.agent);
+    expect(draft).toContain('术语深度档');
+    // review 渐变压图罪状
+    const review = String(def.steps.find((s) => s.id === 'stage_design_review')?.agent);
+    expect(review).toContain('绝不渐变压图');
+    // 生图分辨率 2k（成本不计、高清）
+    const gen = def.steps.find((s) => s.id === 'stage_gen_images');
+    expect(String((gen?.args as Record<string, unknown>)?.size)).toBe('2k');
+  });
+
+  it('视觉优先重构：讲稿通道 speaker_notes + 一页一想法 + 朗读测试（治文本阅读型页面）', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const dd = String(def.steps.find((s) => s.id === 'stage_design_doc')?.agent);
+    // 演讲式内容契约：屏上短语化、论证进讲稿（导出进 PPT 备注栏）、一页一想法、3–5 秒朗读测试
+    expect(dd).toContain('speaker_notes');
+    expect(dd).toContain('一页 = 一个想法');
+    expect(dd).toContain('朗读测试');
+    expect(dd).toContain('evidence 是图表与讲稿的原料');
+    // review 罪状 🅸 文章化页面（量证据自证，内容不删换地方）
+    const review = String(def.steps.find((s) => s.id === 'stage_design_review')?.agent);
+    expect(review).toContain('文章化页面');
+    expect(review).toContain('speaker_notes');
+    // build_batch：讲稿落盘为 hidden aside（不渲染不计上屏字数，导出器写进备注栏）+ 上屏禁扩写
+    const loop = def.steps.find((s) => s.id === 'stage_build_loop');
+    const batch = String(((loop?.do ?? []) as StepDef[]).find((s) => s.id === 'build_batch')?.agent);
+    expect(batch).toContain('speaker-notes');
+    expect(batch).toContain('讲稿落盘');
+    expect(batch).toContain('禁扩写');
+  });
+
+  it('所有 ${} 表达式都能被引擎解析（不含畸形语法）', async () => {
+    const def = await parseWorkflowFile(pptPath);
+    const vars = new VarStack();
+    const inputsObj: Record<string, unknown> = {};
+    for (const inp of def.inputs ?? []) inputsObj[inp.name] = inp.default ?? '';
+    vars.setGlobal('inputs', inputsObj);
+    // 循环变量 img（vision_loop 的 as），给个占位对象让 ${img.file} 可解析
+    vars.set('img', { file: 'src_1.png', orient: 'landscape', section: 's' });
+    vars.set('clarifications', '采用测试风格，面向管理层。');
+    vars.set('vision_json', '{"description":"测试图片"}');
+
+    const strings: string[] = [];
+    const walk = (v: unknown): void => {
+      if (typeof v === 'string') strings.push(v);
+      else if (Array.isArray(v)) for (const x of v) walk(x);
+      else if (v && typeof v === 'object')
+        for (const x of Object.values(v as Record<string, unknown>)) walk(x);
+    };
+    walk(def);
+    for (const s of strings) {
+      if (!s.includes('${')) continue;
+      expect(() => interpolate(s, vars)).not.toThrow();
+    }
+  });
+});