minimal-agent 0.13.0 → 0.14.0

package/plugins/workflow-runner/test/toolRuntimeIntegration.test.ts

@@ -1,168 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-
-import {
-  ALL_TOOLS,
-  type LoopEvent,
-  type Provider,
-  type ToolCallContext,
-  type ToolResult,
-  createAgentRuntimeContext,
-  createSessionState,
-} from '../../../src/plugin-sdk.js';
-import { execToolStep } from '../src/stepExecutors/tool.js';
-import { type RunContext, type StepResult, VarStack } from '../src/types.js';
-
-const provider: Provider = {
-  name: 'workflow-tool-test',
-  baseURL: '',
-  apiKey: '',
-  model: 'fixture',
-  contextWindow: 128_000,
-};
-
-async function collect(
-  generator: AsyncGenerator<LoopEvent, StepResult, void>,
-): Promise<{ events: LoopEvent[]; result: StepResult }> {
-  const events: LoopEvent[] = [];
-  while (true) {
-    const next = await generator.next();
-    if (next.done) return { events, result: next.value };
-    events.push(next.value);
-  }
-}
-
-function makeContext(
-  executeTool: NonNullable<RunContext['executeTool']>,
-): RunContext {
-  const sessionState = createSessionState();
-  sessionState.activeWorktree = {
-    id: 'wt_test',
-    path: '/tmp/workflow-active-worktree',
-    branch: 'workflow/test',
-    baseSha: 'deadbeef',
-    gitRoot: '/tmp/workflow-root',
-  };
-  return {
-    provider,
-    history: [],
-    cwd: '/tmp/workflow-root',
-    tools: ALL_TOOLS,
-    sessionState,
-    runtimeContext: createAgentRuntimeContext({
-      surface: 'workflow',
-      profile: 'main',
-      cwd: '/tmp/workflow-root',
-      workspaceId: 'workspace_test',
-      sessionId: 'session_test',
-      owner: 'local-owner',
-      memoryAccess: 'read-only',
-      interactiveAsk: false,
-    }),
-    promptCache: {
-      scopeKey: 'workflow-test-scope',
-      conversationKey: 'workflow-test-conversation',
-    },
-    executeTool,
-  };
-}
-
-describe('workflow deterministic tool runtime', () => {
-  test('all registered tools use the same generic deterministic node dispatcher', async () => {
-    const dispatched: string[] = [];
-    const ctx = makeContext(async (name) => {
-      dispatched.push(name);
-      return { ok: true, content: `${name} ok` };
-    });
-
-    for (const tool of ALL_TOOLS) {
-      const { result } = await collect(
-        execToolStep(
-          { id: `catalog_${tool.name}`, tool: tool.name, args: {} },
-          new VarStack(),
-          ctx,
-        ),
-      );
-      expect(result.raw).toMatchObject({ content: `${tool.name} ok` });
-    }
-
-    expect(dispatched).toEqual(ALL_TOOLS.map((tool) => tool.name));
-    expect(new Set(dispatched).size).toBe(ALL_TOOLS.length);
-  });
-
-  test('passes canonical runtime context and follows the active worktree cwd', async () => {
-    let captured: ToolCallContext | undefined;
-    const ctx = makeContext(async (_name, _args, _signal, context) => {
-      captured = context;
-      return { ok: true, content: 'ok' };
-    });
-
-    await collect(
-      execToolStep(
-        { id: 'context', tool: 'Read', args: { file_path: 'README.md' } },
-        new VarStack(),
-        ctx,
-      ),
-    );
-
-    expect(captured).toBeDefined();
-    expect(captured?.provider).toBe(provider);
-    expect(captured?.history).toBe(ctx.history);
-    expect(captured?.sessionState).toBe(ctx.sessionState);
-    expect(captured?.workspaceId).toBe('workspace_test');
-    expect(captured?.sessionId).toBe('session_test');
-    expect(captured?.memoryAccess).toBe('read-only');
-    expect(captured?.cwd).toBe('/tmp/workflow-active-worktree');
-    expect(captured?.toolCallId).toBe('wf_context');
-    expect(captured?.promptCache).toBe(ctx.promptCache);
-  });
-
-  test('streams tool progress and preserves structured result fields', async () => {
-    const metadata = {
-      kind: 'process_execution' as const,
-      shell: 'bash' as const,
-      mode: 'foreground' as const,
-      commandKind: 'test' as const,
-      status: 'completed' as const,
-      exitCode: 0,
-    };
-    const ctx = makeContext(async (_name, _args, _signal, context) => {
-      context?.reportProgress?.('running tests');
-      await Promise.resolve();
-      return {
-        ok: true,
-        content: 'tests passed',
-        metadata,
-        recovery: 'none',
-        sensitivity: 'local',
-        visionNote: 'verification image',
-      } satisfies ToolResult;
-    });
-
-    const { events, result } = await collect(
-      execToolStep(
-        { id: 'progress', tool: 'Bash', args: { command: 'bun test' } },
-        new VarStack(),
-        ctx,
-      ),
-    );
-
-    expect(events.map((event) => event.type)).toEqual([
-      'tool_start',
-      'tool_progress',
-      'tool_end',
-    ]);
-    expect(events[1]).toMatchObject({
-      type: 'tool_progress',
-      toolName: 'Bash',
-      toolCallId: 'wf_progress',
-      message: 'running tests',
-    });
-    expect(events[2]).toMatchObject({ type: 'tool_end', metadata });
-    expect(result.raw).toMatchObject({
-      metadata,
-      recovery: 'none',
-      sensitivity: 'local',
-      visionNote: 'verification image',
-    });
-  });
-});

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

@@ -1,250 +0,0 @@
-/**
- * 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 的 out/webppt/${session}/build 下
-    expect(def.steps.find((s) => s.id === 'final_report')?.type).toBe('echo');
-    const declared = def.artifacts ?? [];
-    expect(declared).toContain('out/webppt/${session}/deck.pptx');
-    for (const a of declared) expect(a.startsWith('out/webppt/${session}/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 out/webppt/${session}/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

@@ -1,208 +0,0 @@
-/**
- * test/word.load.test.ts
- * ------------------------------------------------------------
- * 锁定 workflows/word.yaml（素材驱动知乎深度长文 Word 工作流）的
- * 「可解析 + 关键骨架」：
- *   - name=word，最终产物是 out/word/${session}/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/word/${session}/article.docx');
-    for (const a of declared) expect(a.startsWith('out/word/${session}/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/word/${session}/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('out/word/${session}/build/source.md');
-    expect(command).toContain('rm -rf out/word/${session}/build/assets');
-    expect(command).toContain('mkdir -p out/word/${session}/build/assets');
-    expect(command).toContain('out/word/${session}/build/word_topic_image_gate.json');
-    expect(command).toContain('out/word/${session}/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);
-    }
-  });
-});