minimal-agent 0.10.0 → 0.12.0

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

@@ -0,0 +1,250 @@
+/**
+ * test/webppt.load.test.ts
+ * ------------------------------------------------------------
+ * 锁定 workflows/webppt.yaml（网页设计驱动版）的「可解析 + 关键骨架」：
+ *   - loader 校验通过（含 type:loop while 模式 + do[] + break 嵌套）
+ *   - 11 个顶层步、title 分母 /11、inputs 含 topic(greedy)/style/mode/illustrations/out
+ *   - 新流程三段：设计文档(design.json/md+img_plan) → 对抗评审 → 分批生成 loop(deck_pages_check 收口)
+ *   - 复用段衔接正确：img_route_gate 吃 design.json、生图先于闸门、export 只查重叠+每页≤3次+页数兜底
+ *   - 所有 ${} 表达式可被引擎解析（防 bash 参数扩展等畸形语法）
+ *
+ * 定位法：packageRoot/workflows/webppt.yaml + parseWorkflowFile。
+ * 注意：webppt（topic 驱动）与 ppt（文档素材驱动，见 ppt.load.test.ts）是**两个并列的独立工作流**，
+ *       内部 name 分别为 webppt / ppt，互不影响——改 ppt 时绝不动 webppt（用户红线）。
+ */
+
+import { describe, expect, it } from 'bun:test';
+import { join } from 'node:path';
+
+import { 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 webpptPath = join(
+  import.meta.dir.replace(/[/\\]test$/, ''), // plugins/workflow-runner
+  '..', // plugins
+  '..', // 仓库根
+  'workflows',
+  'webppt.yaml',
+);
+
+describe('workflows/webppt.yaml', () => {
+  it('解析通过且 11 步骨架正确', async () => {
+    const def = await parseWorkflowFile(webpptPath);
+
+    expect(def.name).toBe('webppt');
+    expect(typeof def.description).toBe('string');
+
+    // inputs：topic(greedy, 首位) + 高级覆盖项
+    const inputNames = (def.inputs ?? []).map((i) => i.name);
+    expect(inputNames).toEqual(
+      expect.arrayContaining(['topic', 'illustrations', 'style', 'mode', 'out', 'image_intensity']),
+    );
+    expect(inputNames[0]).toBe('topic');
+    // AI 生图积极性配置（2026-06-19）：enum minimal/balanced/rich，默认 balanced
+    const intensity = (def.inputs ?? []).find((i) => i.name === 'image_intensity');
+    expect(intensity?.default).toBe('balanced');
+    expect((def.inputs ?? []).find((i) => i.name === 'topic')?.greedy).toBe(true);
+    expect(inputNames).not.toContain('pages'); // 页数内容驱动，不是输入
+
+    // 11 个顶层步 + title 分母 /11
+    const ids = def.steps.map((s) => s.id);
+    for (const id of [
+      'stage0_clarify',
+      'stage_research',
+      'stage_design_doc',
+      'stage_design_review',
+      'stage_build_loop',
+      'stage_img_route_gate',
+      'stage_gen_images',
+      'stage_export',
+      'verify_output',
+      'cleanup_intermediates',
+      'final_report',
+    ]) {
+      expect(ids).toContain(id);
+    }
+    expect(def.steps.length).toBe(11);
+    for (const s of def.steps) {
+      expect(String(s.title)).toContain('/11');
+    }
+
+    // 收尾报告 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('需求分析步：style 为空时必问视觉样式（VI 选项 + 自定义输入），AskUserQuestion 可用', async () => {
+    const def = await parseWorkflowFile(webpptPath);
+    const s0 = def.steps.find((s) => s.id === 'stage0_clarify');
+    expect(s0?.allowed_tools).toContain('AskUserQuestion');
+    const a = String(s0?.agent);
+    // 样式问是「必做」的强约束（防回归：弱模型曾跳过样式题直接进下一步）。
+    expect(a).toContain('必须调用一次 AskUserQuestion');
+    expect(a).toContain('style 为空');
+    expect(a).toContain('替用户拍板样式');
+    // 仍提供几个最贴合主题的 VI 选项 + 自定义输入。
+    expect(a).toContain('最贴合本主题');
+    expect(a).toContain('自定义');
+  });
+
+  it('设计文档步：产 design.md/json + img_plan，含构图法/渲染决策/呼应提示词/背景变化', async () => {
+    const def = await parseWorkflowFile(webpptPath);
+    const dd = def.steps.find((s) => s.id === 'stage_design_doc');
+    expect(typeof dd?.agent).toBe('string');
+    const a = String(dd?.agent);
+    expect(a).toContain('design.md');
+    expect(a).toContain('design.json');
+    expect(a).toContain('img_plan.json');
+    expect(a).toContain('composition'); // 空间构图法
+    expect(a).toContain('render'); // 元素级渲染决策
+    expect(a).toContain('呼应'); // 生图提示词与文案呼应（治"搬文案"）
+    expect(a).toContain('背景'); // 页面级背景变化
+    expect(a).toContain('每页 ≥1 视觉元素'); // 区别于 Word
+    // 配色解耦（用户裁决）：VI 管底，图表分类色 + 插图内容色
+    expect(a).toContain('配色解耦');
+    expect(a).toContain('分类色');
+    // 保留 visual.{route,note} 字段名 → 下游 image_plan_lint 兼容
+    expect(a).toContain('visual');
+    expect(a).toContain('route');
+    // AI 生图积极性配置接入设计步（2026-06-19）
+    expect(a).toContain('${inputs.image_intensity}'); // 积极性配置驱动配图分流
+    expect(a).toContain('积极性');
+    // design.json 紧凑单行（治 doubao 推理模型写大 JSON 尾部截断 Unterminated string）
+    expect(a).toContain('紧凑单行');
+    expect(String(dd?.done_when)).toContain('design.json');
+    // 编辑式最高标准（第三轮·webppt 也转编辑式，用户授权覆盖红线）：强制默认 + 每页背景层 + cards 罕见例外
+    expect(a).toContain('编辑式最高标准·强制默认');
+    expect(a).toContain('每个内容页都必须有背景层');
+    expect(a).toContain('卡片墙 / 网格 / 表格 = 罕见例外');
+    expect(a).toContain('`cards` 已降为罕见例外、默认别选');
+    // 第五轮：AI 背景默认（渐变只作失败兜底）+ 动笔前三问/苹果式精炼
+    expect(a).toContain('默认高清 AI 图，渐变只作失败兜底');
+    expect(a).toContain('优先配高清 AI 全幅底图');
+    expect(a).toContain('动笔前三问');
+    expect(a).toContain('MacBook Pro');
+  });
+
+  it('对抗评审步：回顾原始需求挑刺并修订定稿（全自动、无人工 pause）', async () => {
+    const def = await parseWorkflowFile(webpptPath);
+    const rv = def.steps.find((s) => s.id === 'stage_design_review');
+    expect(typeof rv?.agent).toBe('string');
+    const a = String(rv?.agent);
+    expect(a).toContain('对抗');
+    expect(a).toContain('原始需求');
+    expect(a).toContain('修订');
+    // 稀疏页标准（用户裁决）：不再一律禁「一句话占一页」，而是 ≤20% 且必须配图/底图避免简陋。
+    expect(a).toContain('20%');
+    expect(a).toContain('简陋');
+    // 配色解耦 + 字号可读性评审子项（用户裁决）
+    expect(a).toContain('分类色'); // 图表数据系列可区分
+    expect(a).toContain('38px'); // 正文放映级可读（≈1.5×）
+    // 新增评审子项（2026-06-19）：封面对比 / 真实 DOM 文本 / 稀疏页满画布
+    expect(a).toContain('对比度'); // 封面/章节文字在浅底图上对比达标
+    expect(a).toContain('DOM 文本'); // 文字皆真实 DOM 文本（无伪元素/烧图文字）
+    expect(a).toContain('占满画布'); // list/目录满宽不留空半
+    // 改 design 文档（Edit/Write），不是只读评审
+    expect(rv?.allowed_tools).toContain('Edit');
+    // 不是 pause（webppt 定位=自动产出，无人工打断）
+    expect(rv?.type).not.toBe('pause');
+  });
+
+  it('分批生成 loop：while + fresh_context + deck_pages_check 收口（防大 deck 烂尾）', async () => {
+    const def = await parseWorkflowFile(webpptPath);
+    const loop = def.steps.find((s) => s.id === 'stage_build_loop');
+    expect(loop?.type).toBe('loop');
+    expect(loop?.fresh_context).toBe(true); // 每轮重置 history 防膨胀
+    expect(loop?.over).toBeUndefined(); // while 模式（非 for-each）
+    expect(typeof loop?.max_iterations === 'number' || typeof loop?.max_iterations === 'string').toBe(true);
+    const dos = (loop?.do ?? []) as StepDef[];
+    const batch = dos.find((s) => s.id === 'build_batch');
+    const brk = dos.find((s) => s.id === 'build_done');
+    // 生成步：跑 deck_pages_check 自查 + ≤5 页 + 每页视觉元素 + COMPLETE 标记
+    expect(typeof batch?.agent).toBe('string');
+    expect(String(batch?.agent)).toContain('deck_pages_check.py');
+    expect(String(batch?.agent)).toContain('WEBPPT_BUILD_COMPLETE');
+    expect(String(batch?.agent)).toContain('5 页'); // 每轮最多 5 页
+    // 字号阶梯（放映级正文 ≈1.5×）+ 配色解耦（图表分类色）注入生成步
+    expect(String(batch?.agent)).toContain('38px'); // 正文/卡片正文放映级下限（≈1.5×）
+    expect(String(batch?.agent)).toContain('分类色'); // 图表数据系列分类色
+    // 文本必须真实 DOM（禁伪元素/烧图）+ 封面对比 + 稀疏页满画布（2026-06-19）
+    expect(String(batch?.agent)).toContain('真实 DOM 文本'); // 禁 ::before/::after / 禁烧进图
+    expect(String(batch?.agent)).toContain('::before/::after'); // 明示禁用伪元素文字
+    expect(String(batch?.agent)).toContain('对比度铁律'); // 封面浅底图深字+浅板
+    expect(String(batch?.agent)).toContain('占满整宽'); // list/目录满宽不留空半
+    // 递归切图：可拖结构离散 HTML + 卡片填实/不溢出（2026-06-19）
+    expect(String(batch?.agent)).toContain('可拖结构'); // 离散 HTML 元素、递归切成各自可拖对象
+    expect(String(batch?.agent)).toContain('递归切'); // 导出递归切
+    expect(String(batch?.agent)).toContain('卡片/分组填充不足'); // 填实/不溢出 WARNING 提示
+    // 对比度铁律 + 文案精炼说人话 + 排不下自救（2026-06-19 第三轮）
+    expect(String(batch?.agent)).toContain('文字对比度铁律'); // 深底白字、绝不深底深字
+    expect(String(batch?.agent)).toContain('说人话'); // 文案精炼·类比/例子
+    expect(String(batch?.agent)).toContain('两列'); // 排不下改 grid 两列
+    // deck 纵向流式（人可滚动审阅，不再各页叠在一起）
+    expect(String(batch?.agent)).toContain('流式'); // 纵向流式版式
+    expect(String(batch?.agent)).toContain('position:relative'); // 每页 position:relative 排开
+    expect(batch?.capture).toBeTruthy();
+    // break：页数 COMPLETE 时跳出循环
+    expect(brk?.type).toBe('break');
+    expect(String(brk?.when)).toContain('WEBPPT_BUILD_COMPLETE');
+  });
+
+  it('衔接：img_route_gate 吃 design.json、生图先于闸门、export 只查重叠+每页≤3次+页数兜底', async () => {
+    const def = await parseWorkflowFile(webpptPath);
+    const ids = def.steps.map((s) => s.id);
+
+    // 配图分流闸门：image_plan_lint 的 --outline 直接吃 design.json
+    const gate = def.steps.find((s) => s.id === 'stage_img_route_gate');
+    expect(String(gate?.agent)).toContain('image_plan_lint.py');
+    expect(String(gate?.agent)).toContain('--outline ./build/design.json');
+    expect(String(gate?.done_when)).toContain('img_route_ok');
+    // 顺序：build_loop → img_route_gate → gen_images
+    expect(ids.indexOf('stage_img_route_gate')).toBeGreaterThan(ids.indexOf('stage_build_loop'));
+    expect(ids.indexOf('stage_img_route_gate')).toBeLessThan(ids.indexOf('stage_gen_images'));
+    // 生图先于构图闸门（闸门量含图成品）——分层/时序不变量
+    expect(ids.indexOf('stage_gen_images')).toBeLessThan(ids.indexOf('stage_export'));
+
+    // 导出步：页数兜底 + measure-only 渲染含图成品 + 只查重叠 + 修法序(移动>精炼>缩字≤20%) + 每页≤3次配额 + 哨兵
+    const exp = def.steps.find((s) => s.id === 'stage_export');
+    expect(String(exp?.agent)).toContain('deck_pages_check.py'); // 页数兜底
+    expect(String(exp?.agent)).toContain('layout_balance.py');
+    expect(String(exp?.agent)).toContain('--measure-only'); // 渲染真实 deck 量含图成品
+    expect(String(exp?.agent)).toContain('重叠'); // 不可妥协硬门之一
+    expect(String(exp?.agent)).toContain('截图夹带文本'); // 底图/切图绝不能带 HTML 文字（硬门，2026-06-19）
+    // 改 deck.html 只准用 Edit、禁 Bash 文本替换（治弱模型 type/findstr/PowerShell 把 HTML 改崩→halt，2026-06-19 第三轮）
+    expect(String(exp?.agent)).toContain('只准用 Edit');
+    expect(String(exp?.agent)).toContain('编码损坏');
+    expect(String(exp?.agent)).toContain('移动'); // 修重叠优先移动/重排（不是一味缩字）
+    expect(String(exp?.agent)).toContain('20%'); // 缩字单次封顶 20%
+    expect(String(exp?.agent)).toContain('3 次'); // 每页最多修 3 次
+    expect(String(exp?.agent)).toContain('放行'); // 第 3 次后必放行
+    expect(String(exp?.done_when)).toContain('layout_ok');
+    expect(String(exp?.done_when)).toContain('inputs.out');
+    expect(exp?.maxTurns).toBe(200);
+  });
+
+  it('所有 ${} 表达式都能被引擎解析（不含畸形语法）', async () => {
+    const def = await parseWorkflowFile(webpptPath);
+    const vars = new VarStack();
+    const inputsObj: Record<string, unknown> = {};
+    for (const inp of def.inputs ?? []) inputsObj[inp.name] = inp.default ?? '';
+    vars.setGlobal('inputs', inputsObj);
+
+    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);
+    expect(strings.length).toBeGreaterThan(10);
+    for (const s of strings) {
+      if (!s.includes('${')) continue;
+      expect(() => interpolate(s, vars)).not.toThrow();
+    }
+  });
+});

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

@@ -0,0 +1,208 @@
+/**
+ * test/word.load.test.ts
+ * ------------------------------------------------------------
+ * 锁定 workflows/word.yaml（素材驱动知乎深度长文 Word 工作流）的
+ * 「可解析 + 关键骨架」：
+ *   - name=word，最终产物是 ./out/article.docx
+ *   - inputs 支持 topic(greedy) / source / out / image_intensity / quality / debug_keep_build
+ *   - Markdown-first：material → outline → article.md → image_map/img_plan → docx skill → OPC
+ *   - 客户图必须使用；需要解释型视觉时积极文生图，提示词必须结合上下文
+ *   - 不引入 PPT 专属 deck.html / design.json / 构图门 / PPTX 导出链路
+ */
+
+import { describe, expect, it } from 'bun:test';
+import { join } from 'node:path';
+
+import { parseWorkflowFile } from '../src/loader.js';
+
+const wordPath = join(
+  import.meta.dir.replace(/[/\\]test$/, ''), // plugins/workflow-runner
+  '..', // plugins
+  '..', // minimal-agent 根
+  'workflows',
+  'word.yaml',
+);
+
+describe('workflows/word.yaml（素材驱动·知乎深度长文 Word）', () => {
+  it('解析通过且 name/artifacts/inputs 骨架正确', async () => {
+    const def = await parseWorkflowFile(wordPath);
+
+    expect(def.name).toBe('word');
+    expect(typeof def.description).toBe('string');
+    expect(def.description).toContain('知乎深度文章');
+
+    const declared = def.artifacts ?? [];
+    expect(declared).toContain('./out/article.docx');
+    for (const a of declared) expect(a.startsWith('./build')).toBe(false);
+
+    const inputNames = (def.inputs ?? []).map((i) => i.name);
+    expect(inputNames).toEqual(
+      expect.arrayContaining([
+        'topic',
+        'source',
+        'out',
+        'image_intensity',
+        'quality',
+        'debug_keep_build',
+      ]),
+    );
+    expect(inputNames[0]).toBe('topic');
+    expect((def.inputs ?? []).find((i) => i.name === 'topic')?.greedy).toBe(true);
+    expect((def.inputs ?? []).find((i) => i.name === 'out')?.default).toBe(
+      './out/article.docx',
+    );
+  });
+
+  it('步骤骨架包含素材、识图、长文、图文混排、docx 导出与校验', async () => {
+    const def = await parseWorkflowFile(wordPath);
+    const ids = def.steps.map((s) => s.id);
+
+    for (const id of [
+      'stage0_analyze',
+      'stage_extract',
+      'stage_vision_loop',
+      'stage_assemble_material',
+      'stage_outline',
+      'stage_write_article',
+      'stage_img_plan',
+      'stage_gen_images',
+      'stage_generated_image_gate',
+      'stage_finalize_markdown',
+      'stage_topic_image_gate',
+      'stage_customer_image_gate',
+      'stage_export_docx',
+      'stage_verify_docx',
+      'final_report',
+    ]) {
+      expect(ids).toContain(id);
+    }
+
+    expect(def.steps.find((s) => s.id === 'stage_export_docx')?.skill).toBe(
+      'docx',
+    );
+    expect(def.steps.find((s) => s.id === 'stage_verify_docx')?.tool).toBe(
+      'Bash',
+    );
+    expect(def.steps.find((s) => s.id === 'final_report')?.type).toBe('echo');
+  });
+
+  it('锁定 Word 核心约束：知乎长文、客户图全用、上下文生图、docx OPC', async () => {
+    const def = await parseWorkflowFile(wordPath);
+    const all = JSON.stringify(def, null, 2);
+
+    for (const needle of [
+      '知乎深度文章',
+      '总结',
+      '扩写',
+      '观点',
+      '论证',
+      '图文混排',
+      '所有客户图',
+      '必须使用',
+      'source_file',
+      'final_file',
+      'article_section',
+      'material.md',
+      'article.md',
+      'skill: docx',
+      'markdown-implicit_figures',
+      'implicit_figures',
+      'OPC',
+      'opc_check.py',
+      'WORD_DOCX_PNG_CONTENT_TYPE_ADDED',
+      '无客户图',
+      '纯 topic',
+      '至少 3',
+      '至少 5',
+      '不得为空',
+      'text-to-image',
+    ]) {
+      expect(all).toContain(needle);
+    }
+
+    expect(all).toContain('现代科技风');
+    expect(all).toContain('知乎配图');
+    expect(all).toContain('抽象背景');
+    expect(all).toContain('禁止空泛');
+    expect(all).toContain('避免 Markdown 图片 alt 文本被渲染成额外可见图注');
+  });
+
+  it('纯 topic 模式：无客户图也必须按 image_intensity 生成文生图并闸门校验', async () => {
+    const def = await parseWorkflowFile(wordPath);
+    const gate = def.steps.find((s) => s.id === 'stage_topic_image_gate');
+    const all = JSON.stringify(def, null, 2);
+    const gateText = JSON.stringify(gate, null, 2);
+    const gateCommand = String(gate?.args?.command ?? '');
+
+    expect(gate?.tool).toBe('Bash');
+    expect(gateText).toContain('pure topic mode');
+    expect(gateText).toContain('WORD_TOPIC_IMAGE_GATE_FAILED');
+    expect(gateCommand).toContain('"minimal": 1');
+    expect(gateCommand).toContain('"balanced": 3');
+    expect(gateCommand).toContain('"rich": 5');
+    expect(gateText).toContain('img_plan.json');
+    expect(gateText).toContain('image_map.json');
+    expect(gateText).toContain('article.md');
+    expect(gateText).toContain('text-to-image');
+
+    for (const needle of [
+      'img_plan.json` 不得为空',
+      '`minimal`：至少 1 张',
+      '`balanced`：至少 3 张',
+      '`rich`：至少 5 张',
+      '`file`、`mode`、`aspect`、`prompt`',
+      '`mode` 必须是 `text-to-image`',
+      '章节观点、上下文、场景和图注意图',
+    ]) {
+      expect(all).toContain(needle);
+    }
+  });
+
+  it('stage_extract 清理旧素材残留，纯 topic 不会误读上次 source/assets', async () => {
+    const def = await parseWorkflowFile(wordPath);
+    const extract = def.steps.find((s) => s.id === 'stage_extract');
+    const command = String(extract?.args?.command ?? '');
+
+    expect(command).toContain('./build/source.md');
+    expect(command).toContain('rm -rf ./build/assets');
+    expect(command).toContain('mkdir -p ./build/assets');
+    expect(command).toContain('./build/word_topic_image_gate.json');
+    expect(command).toContain('./build/word_topic_image_gate.md');
+  });
+
+  it('生成配图失败时会在导出前硬失败，不会把渐变占位图交付进 Word', async () => {
+    const def = await parseWorkflowFile(wordPath);
+    const gate = def.steps.find((s) => s.id === 'stage_generated_image_gate');
+    const command = String(gate?.args?.command ?? '');
+
+    expect(gate?.tool).toBe('Bash');
+    expect(gate?.onError).toBe('halt');
+    expect(String(gate?.when)).toContain('image_generation_report.json');
+    expect(command).toContain('qualityOk');
+    expect(command).toContain('8192');
+    expect(command).toContain('WORD_GENERATED_IMAGE_GATE_FAILED');
+  });
+
+  it('不包含 PPT 专属固定画布 / HTML deck / PPTX 导出链路', async () => {
+    const def = await parseWorkflowFile(wordPath);
+    const all = JSON.stringify(def, null, 2);
+    const ids = def.steps.map((s) => s.id);
+
+    for (const forbiddenId of [
+      'stage_design_doc',
+      'stage_build_loop',
+      'visual_quality_gate',
+      'stage_export_pptx',
+    ]) {
+      expect(ids).not.toContain(forbiddenId);
+    }
+    for (const forbidden of [
+      'deck.html',
+      'design.json',
+      'export_pptx',
+      'visual_quality_gate',
+    ]) {
+      expect(all).not.toContain(forbidden);
+    }
+  });
+});

package/plugins/workflow-runner/test/workflows.smoke.test.ts

@@ -0,0 +1,76 @@
+/**
+ * ============================================================
+ *  test/workflows.smoke.test.ts
+ * ------------------------------------------------------------
+ *  内置工作流「解析+校验」冒烟测试 —— 守护「引擎对所有 workflows/*.yaml 的通用支持」。
+ *
+ *  为什么需要它（真实缺口）：
+ *    `listWorkflows()` 对损坏 yaml 是**静默跳过**（loader.ts catch→warn→continue），
+ *    而既有 loader 单测只显式校验了 book-review-short.yaml 一个内置工作流。
+ *    于是若某次引擎/loader/schema 改动破坏了 plan / youtube-shorts / adaptive-research /
+ *    e2e-write-greet 等的结构，**没有任何测试会失败**——它只会被悄悄忽略。
+ *    本文件把「每个内置工作流都能 parse + validate 通过」锁成不变量：任一被改坏即红。
+ *
+ *  隔离性（同 loader.test.ts 的教训）：
+ *    直接定位 packageRoot 的 workflows 目录 + `parseWorkflowFile()` 逐个解析，
+ *    **零依赖 getWorkingDir() 全局状态**，避免其它测试文件经 mock.module 留下的污染。
+ * ============================================================
+ */
+
+import { describe, expect, it } from 'bun:test';
+import { readdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { parseWorkflowFile } from '../src/loader.js';
+
+// packageRoot 下的 workflows 目录（不依赖 getWorkingDir）。
+// import.meta.dir = plugins/workflow-runner/test；向上三级到 minimal-agent 根。
+// 兼容 Windows：用 [/\\] 同时匹配两种路径分隔符（同 loader.test.ts:94 的教训）。
+const WORKFLOWS_DIR = join(
+  import.meta.dir.replace(/[/\\]test$/, ''), // plugins/workflow-runner
+  '..', // plugins
+  '..', // minimal-agent 根
+  'workflows',
+);
+
+// 内置工作流的「全集快照」：意外删除/改名任一个即红（防止悄悄少掉一个工作流）。
+const EXPECTED_WORKFLOWS = [
+  'adaptive-research',
+  'book-review-short',
+  'e2e-write-greet',
+  'plan',
+  'ppt',
+  'ralph-loop',
+  'webppt',
+  'word',
+  'youtube-shorts',
+].sort();
+
+function yamlFiles(): string[] {
+  return readdirSync(WORKFLOWS_DIR)
+    .filter((f) => f.endsWith('.yaml') || f.endsWith('.yml'))
+    .sort();
+}
+
+describe('内置 workflows/*.yaml 解析+校验冒烟', () => {
+  // 逐个文件成测：哪个被改坏，失败信息直接点名是哪个工作流。
+  for (const file of yamlFiles()) {
+    it(`${file} 能被 parseWorkflowFile 解析且通过校验`, async () => {
+      const def = await parseWorkflowFile(join(WORKFLOWS_DIR, file));
+      expect(typeof def.name).toBe('string');
+      expect(def.name.length).toBeGreaterThan(0);
+      expect(def.description.length).toBeGreaterThan(0);
+      expect(def.steps.length).toBeGreaterThan(0);
+    });
+  }
+
+  it('内置工作流全集齐全（没有被悄悄删除/改名）', async () => {
+    const defs = await Promise.all(
+      yamlFiles().map((f) => parseWorkflowFile(join(WORKFLOWS_DIR, f))),
+    );
+    const names = defs.map((d) => d.name).sort();
+    for (const expected of EXPECTED_WORKFLOWS) {
+      expect(names).toContain(expected);
+    }
+  });
+});