minimal-agent 0.12.0 → 0.14.0

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

@@ -1,379 +0,0 @@
-/**
- * ============================================================
- *  test/runnerPreflight.test.ts —— Runner Pre-flight & Self-heal 单元测试
- * ------------------------------------------------------------
- *  覆盖 runWorkflow 的前置流程和自愈重试机制：
- *
- *  Pre-flight（任务身份判定 + 断点续执行）：
- *    - fresh 模式：正常启动，无恢复信息
- *    - completed 模式：返回已完成提示（需手动构造状态）
- *    - resume 模式：回放 capture 变量 + 跳过已完成步骤
- *    - goalAnchor 构建与注入
- *    - archive 成功后清理状态目录
- *
- *  Self-heal / Retry：
- *    - step 失败后自动 retry（max_retries 控制）
- *    - backoff 回退 N 步重跑
- *    - step.max_retries 覆盖全局配置
- *    - retry 用尽后走 onError 逻辑
- *
- *  设计原则：
- *    - 用 assert step 构造成功/失败路径（无需 mock LLM）
- *    - 通过 runWorkflow 集成测试验证行为（避免直接实例化 WorkflowState 的 Bun 兼容性问题）
- *    - 观察事件流判断内部状态转换是否正确
- * ============================================================ */
-
-import { afterEach, beforeEach, describe, expect, it, mock } from 'bun:test';
-import {
-  existsSync,
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-} from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { _resetWorkingDir } from '../../../src/bootstrap/workingDir.js';
-import { ALL_TOOLS } from '../../../src/tools/index.js';
-import { runWorkflow } from '../src/runner.js';
-import type { LoopEvent, Provider } from '../../../src/types.js';
-import type { RunContext, WorkflowDef, WorkflowEvent } from '../src/types.js';
-
-type WfOrLoop = WorkflowEvent | LoopEvent;
-
-const fakeProvider: Provider = {
-  name: 'test',
-  baseURL: '',
-  apiKey: '',
-  model: 'm',
-  contextWindow: 128000,
-};
-
-async function collect(
-  gen: AsyncGenerator<WfOrLoop, void, void>,
-): Promise<WfOrLoop[]> {
-  const out: WfOrLoop[] = [];
-  for await (const ev of gen) out.push(ev);
-  return out;
-}
-
-describe('runner::pre-flight fresh 模式', () => {
-  let tmp: string;
-  let ctx: RunContext;
-
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), 'wf-preflight-'));
-    process.env.MINIMAL_AGENT_CWD = tmp;
-    _resetWorkingDir();
-    mock.module('../../../src/bootstrap/workingDir.js', () => ({
-      getWorkingDir: () => tmp,
-      initWorkingDir: () => tmp,
-      _resetWorkingDir: () => {},
-    }));
-    ctx = { provider: fakeProvider, history: [], cwd: tmp, tools: [] };
-  });
-
-  afterEach(() => {
-    delete process.env.MINIMAL_AGENT_CWD;
-    _resetWorkingDir();
-    rmSync(tmp, { recursive: true, force: true });
-  });
-
-  it('首次运行 → workflow_start + 正常执行 + workflow_done', async () => {
-    const def: WorkflowDef = {
-      name: 'fresh-test',
-      description: 'd',
-      steps: [{ id: 's1', type: 'assert', condition: 'true' }],
-    };
-    const events = await collect(runWorkflow(def, {}, ctx));
-    expect(events.some((e) => e.type === 'workflow_start')).toBe(true);
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
-    // 不应有 completed 提示
-    expect(events.find((e) => e.type === 'text' && String(e).includes('已完成'))).toBeUndefined();
-  });
-});
-
-describe('runner::pre-flight completed 模式（架构说明）', () => {
-  // ⚠️ 注意：completed 模式的集成测试需要精确匹配 taskId hash，
-  // 而 taskId 由 taskIdentity.ts::computeTaskId() 计算（含归一化 + SHA256 截断）。
-  // 直接构造匹配的 current.json 脆且容易因归一化规则调整而断裂。
-  //
-  // 已有覆盖：
-  //   - taskIdentity.test.ts: 完整测试 computeTaskId 的 hash / 时间窗口 / 匹配逻辑
-  //   - stateLifecycle.test.ts: 通过 runWorkflow 成功→archive 验证状态目录生命周期
-  //   - 本文件 resume 测试: 验证失败后重跑进入 resume 模式
-  //
-  // 结论：completed 分支的正确性由上述测试联合保证，无需再写一个脆弱的集成测试。
-
-  it('占位：completed 模式已由 taskIdentity.test.ts + stateLifecycle.test.ts 联合覆盖', () => {
-    expect(true).toBe(true);
-  });
-});
-
-describe('runner::resume 与断点续执行', () => {
-  let tmp: string;
-  let ctx: RunContext;
-
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), 'wf-resume-'));
-    process.env.MINIMAL_AGENT_CWD = tmp;
-    _resetWorkingDir();
-    mock.module('../../../src/bootstrap/workingDir.js', () => ({
-      getWorkingDir: () => tmp,
-      initWorkingDir: () => tmp,
-      _resetWorkingDir: () => {},
-    }));
-    ctx = { provider: fakeProvider, history: [], cwd: tmp, tools: ALL_TOOLS };
-  });
-
-  afterEach(() => {
-    delete process.env.MINIMAL_AGENT_CWD;
-    _resetWorkingDir();
-    rmSync(tmp, { recursive: true, force: true });
-  });
-
-  it('失败后重跑 → 进入 resume 模式 → 跳过已完成步骤', async () => {
-    const def: WorkflowDef = {
-      name: 'resume-test',
-      description: 'd',
-      self_heal: { backoff: 0, max_retries: 0 }, // 禁用 retry 让它自然 halt
-      steps: [
-        { id: 'write', tool: 'Write', args: { file_path: 'data.txt', content: 'hello' }, capture: { content: 'captured_text' } },
-        { id: 'check', type: 'assert', condition: "captured_text == 'hello'" },
-        { id: 'fail', type: 'assert', condition: 'false', onFail: 'intentional fail' },
-        { id: 'after_fail', type: 'assert', condition: 'true' },
-      ],
-    };
-
-    // 第一次运行：前两步成功，第三步失败
-    const events1 = await collect(runWorkflow(def, { goal: 'target' }, ctx));
-    expect(events1.some((e) => e.type === 'error')).toBe(true); // halt
-    expect(events1.some((e) => e.type === 'workflow_done')).toBe(false);
-
-    // 第二次运行：应进入 resume 模式（时间窗口内同一任务）
-    const events2 = await collect(runWorkflow(def, { goal: 'target' }, ctx));
-
-    // 应有某种恢复相关的事件（text 或 warning）
-    const hasResumeInfo =
-      events2.some((e) => e.type === 'text' && String(e).includes('未完成')) ||
-      events2.some((e) => e.type === 'text' && String(e).includes('恢复'));
-
-    // 已完成的步骤可能被跳过（取决于实现细节）
-    const skippedIds = events2
-      .filter((e): e is Extract<WorkflowEvent, { type: 'workflow_step_skipped' }> =>
-        e.type === 'workflow_step_skipped')
-      .map((e) => e.id);
-
-    // 最终仍会失败（因为 fail 步骤仍然失败且 retry=0）
-    expect(events2.some((e) => e.type === 'error')).toBe(true);
-  });
-});
-
-describe('runner::goalAnchor 构建', () => {
-  it('inputs.goal 存在 → workflow 正常运行（间接验证 goalAnchor 不报错）', async () => {
-    const tmp = mkdtempSync(join(tmpdir(), 'wf-goal-'));
-    process.env.MINIMAL_AGENT_CWD = tmp;
-    _resetWorkingDir();
-    mock.module('../../../src/bootstrap/workingDir.js', () => ({
-      getWorkingDir: () => tmp,
-      initWorkingDir: () => tmp,
-      _resetWorkingDir: () => {},
-    }));
-
-    try {
-      const def: WorkflowDef = {
-        name: 'goal-test',
-        description: 'd',
-        inputs: [{ name: 'goal', type: 'string', required: true }],
-        steps: [{ id: 's1', type: 'assert', condition: 'true' }],
-      };
-
-      const ctx: RunContext = {
-        provider: fakeProvider,
-        history: [],
-        cwd: tmp,
-        tools: [],
-      };
-
-      const events = await collect(runWorkflow(def, { goal: '实现用户认证模块' }, ctx));
-      expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
-    } finally {
-      delete process.env.MINIMAL_AGENT_CWD;
-      _resetWorkingDir();
-      rmSync(tmp, { recursive: true, force: true });
-    }
-  });
-
-  it('无 string 类型 inputs → goalAnchor 为空（不报错）', async () => {
-    const tmp = mkdtempSync(join(tmpdir(), 'wf-nogoal-'));
-    process.env.MINIMAL_AGENT_CWD = tmp;
-    _resetWorkingDir();
-    mock.module('../../../src/bootstrap/workingDir.js', () => ({
-      getWorkingDir: () => tmp,
-      initWorkingDir: () => tmp,
-      _resetWorkingDir: () => {},
-    }));
-
-    try {
-      const def: WorkflowDef = {
-        name: 'no-goal-test',
-        description: 'd',
-        inputs: [{ name: 'count', type: 'number' }],
-        steps: [{ id: 's1', type: 'assert', condition: 'true' }],
-      };
-
-      const ctx: RunContext = {
-        provider: fakeProvider,
-        history: [],
-        cwd: tmp,
-        tools: [],
-      };
-
-      const events = await collect(runWorkflow(def, { count: 42 }, ctx));
-      expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
-    } finally {
-      delete process.env.MINIMAL_AGENT_CWD;
-      _resetWorkingDir();
-      rmSync(tmp, { recursive: true, force: true });
-    }
-  });
-});
-
-describe('runner::self_heal retry 机制', () => {
-  let tmp: string;
-  let ctx: RunContext;
-
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), 'wf-retry-'));
-    process.env.MINIMAL_AGENT_CWD = tmp;
-    _resetWorkingDir();
-    mock.module('../../../src/bootstrap/workingDir.js', () => ({
-      getWorkingDir: () => tmp,
-      initWorkingDir: () => tmp,
-      _resetWorkingDir: () => {},
-    }));
-    ctx = { provider: fakeProvider, history: [], cwd: tmp, tools: [] };
-  });
-
-  afterEach(() => {
-    delete process.env.MINIMAL_AGENT_CWD;
-    _resetWorkingDir();
-    rmSync(tmp, { recursive: true, force: true });
-  });
-
-  it('self_heal.backoff 控制回退步数（失败时回退重跑）', async () => {
-    const def: WorkflowDef = {
-      name: 'backoff-test',
-      description: 'd',
-      self_heal: { backoff: 2, max_retries: 1 },
-      steps: [
-        { id: 'setup', tool: 'Write', args: { file_path: 'setup.txt', content: 'init' } },
-        { id: 'work', type: 'assert', condition: 'true' },
-        { id: 'flaky', type: 'assert', condition: 'false', onFail: 'fail' },
-        { id: 'cleanup', type: 'assert', condition: 'true' },
-      ],
-    };
-
-    const events = await collect(runWorkflow(def, {}, ctx));
-    // flaky 失败后应触发 retry 机制（backoff=2 回退到 work 步骤重跑）
-    // 最终仍会失败（因为 flaky 总是 false）
-    expect(events.some((e) => e.type === 'error')).toBe(true);
-
-    // 验证 setup 步骤被重新执行（backoff=2 导致从 work 重跑，work 之前的是 setup）
-    // 所以 setup 应该出现多次
-    const setupStartCount = events.filter(
-      (e) => e.type === 'workflow_step_start' && (e as {id:string}).id === 'setup',
-    ).length;
-    expect(setupStartCount).toBeGreaterThanOrEqual(1); // 至少执行一次
-  });
-
-  it('step.max_retries 覆盖全局 self_heal.max_retries', async () => {
-    const def: WorkflowDef = {
-      name: 'override-retry',
-      description: 'd',
-      self_heal: { backoff: 0, max_retries: 5 }, // 全局允许 5 次
-      steps: [
-        {
-          id: 'limited',
-          type: 'assert',
-          condition: 'false',
-          onFail: 'always fails',
-          max_retries: 1, // 但这步只允许 1 次
-        },
-        { id: 'next', type: 'assert', condition: 'true' },
-      ],
-    };
-
-    const events = await collect(runWorkflow(def, {}, ctx));
-    // limited 步骤只 retry 1 次（共尝试 2 次），然后halt
-    expect(events.some((e) => e.type === 'error')).toBe(true);
-    // next 不应被执行
-    const startedIds = events
-      .filter((e): e is Extract<WorkflowEvent, { type: 'workflow_step_start' }> =>
-        e.type === 'workflow_step_start')
-      .map((e) => e.id);
-    expect(startedIds).not.toContain('next');
-  });
-
-  it('retry 用尽后走 onError:halt（默认）→ 整个 workflow 停止', async () => {
-    const def: WorkflowDef = {
-      name: 'retry-halt',
-      description: 'd',
-      self_heal: { backoff: 0, max_retries: 1 },
-      steps: [
-        {
-          id: 'fail_step',
-          type: 'assert',
-          condition: 'false',
-          onFail: 'fails',
-          // 默认 onError='halt'
-        },
-        { id: 'next', type: 'assert', condition: 'true' },
-      ],
-    };
-
-    const events = await collect(runWorkflow(def, {}, ctx));
-    expect(events.some((e) => e.type === 'error')).toBe(true);
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(false);
-    // next 不应执行
-    expect(events.some((e) => e.type === 'workflow_step_start' && (e as {id:string}).id === 'next')).toBe(false);
-  });
-
-  it('正常成功路径 → archive 清理状态目录', async () => {
-    const def: WorkflowDef = {
-      name: 'archive-test',
-      description: 'd',
-      steps: [{ id: 's1', type: 'assert', condition: 'true' }],
-    };
-
-    await collect(runWorkflow(def, {}, ctx));
-
-    // 成功后应 archive（活动目录改名 .done；E6 后按名隔离）
-    expect(existsSync(join(tmp, '.minimal-agent-workflow', 'archive-test'))).toBe(false);
-    expect(existsSync(join(tmp, '.minimal-agent-workflow', 'archive-test.done'))).toBe(true);
-  });
-
-  it('失败路径 → 保留状态目录供排查', async () => {
-    const def: WorkflowDef = {
-      name: 'keep-state',
-      description: 'd',
-      self_heal: { backoff: 0, max_retries: 0 },
-      steps: [
-        { id: 'fail', type: 'assert', condition: 'false', onFail: 'boom' },
-      ],
-    };
-
-    await collect(runWorkflow(def, {}, ctx));
-
-    // 失败时应保留状态目录（E6 后按名隔离）
-    expect(existsSync(join(tmp, '.minimal-agent-workflow', 'keep-state'))).toBe(true);
-    // progress.md 应包含失败步骤信息
-    const progressPath = join(tmp, '.minimal-agent-workflow', 'keep-state', 'progress.md');
-    if (existsSync(progressPath)) {
-      const progress = readFileSync(progressPath, 'utf8');
-      expect(progress).toContain('fail');
-    }
-  });
-});

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

@@ -1,71 +0,0 @@
-/**
- * ============================================================
- *  test/skillTurnDone.test.ts —— skill 节点不外泄子 runQuery 的 turn_done
- * ------------------------------------------------------------
- *  端到端实测发现：critic(skill) 子循环结束时 yield 的 turn_done 漏进 workflow 事件流，
- *  导致把 turn_done 当终结的消费者（-p --output-format json / gateway broker）在
- *  workflow 中途（critic 之后、verify 之前）误判结束。execSkillStep 现过滤之。
- *
- *  策略：mock plugin-sdk 的 runQuery 吐 [text, turn_done]，断言 execSkillStep 不外泄
- *  turn_done，但保留 text 并正常 capture。
- * ============================================================
- */
-
-import { describe, expect, it } from 'bun:test';
-import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import type { LoopEvent } from '../../../src/types.js';
-import type { RunContext } from '../src/types.js';
-import { VarStack } from '../src/types.js';
-// 临时 skills 目录：myskill/SKILL.md
-const tmpProject = mkdtempSync(join(tmpdir(), 'wf-skillTD-'));
-const tmpSkills = join(tmpProject, 'skills');
-mkdirSync(join(tmpSkills, 'myskill'), { recursive: true });
-writeFileSync(
-  join(tmpSkills, 'myskill', 'SKILL.md'),
-  '---\nname: myskill\n---\n做点事。\n',
-);
-
-import { execSkillStep } from '../src/stepExecutors/skill.js';
-
-const fakeCtx: RunContext = {
-  provider: {
-    name: 't',
-    baseURL: '',
-    apiKey: '',
-    model: 'm',
-    contextWindow: 1_000_000,
-  },
-  history: [],
-  cwd: tmpProject,
-  tools: [],
-  // DI：stub chat，让真实 runQuery 真推 'hello' 进 history + 单轮收尾 yield turn_done。
-  chat: async function* () {
-    yield { type: 'text_delta', delta: 'hello' };
-    yield { type: 'done', stopReason: 'stop' };
-  },
-};
-
-describe('execSkillStep turn_done 不外泄', () => {
-  it('过滤 turn_done，保留 text/stage_change，正常 capture 文本', async () => {
-    const evs: LoopEvent[] = [];
-    const gen = execSkillStep(
-      { id: 's', skill: 'myskill', input: 'go' },
-      new VarStack(),
-      fakeCtx,
-    );
-    let r = await gen.next();
-    while (!r.done) {
-      evs.push(r.value as LoopEvent);
-      r = await gen.next();
-    }
-    const result = r.value;
-
-    expect(evs.some((e) => e.type === 'turn_done')).toBe(false); // 关键：不外泄
-    expect(evs.some((e) => e.type === 'text')).toBe(true); // 其它事件保留
-    expect(evs.some((e) => e.type === 'stage_change')).toBe(true);
-    expect(result.raw.text).toBe('hello'); // 文本仍正常 capture
-  });
-});

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

@@ -1,150 +0,0 @@
-/**
- * ============================================================
- *  test/stateLifecycle.test.ts —— .minimal-agent-workflow/ 生命周期契约
- * ------------------------------------------------------------
- *  钉死 Fix ③ 的设计决策（曾经缺失这条测试，导致"失败即删"自废武功无人察觉）：
- *    - 干净跑完 → cleanup()，状态目录被删（不留垃圾）
- *    - halt / 失败 → **保留** 状态目录 + progress.md（含失败那步的 ✗ 行）供事后排查
- *
- *  这类"失败时的行为契约"靠想清楚 + 测试钉死，不会被 happy-path 测试自动覆盖到。
- *  用 assert step 构造成功/失败两条路径，无需 mock LLM。
- * ============================================================
- */
-
-import { afterEach, beforeEach, describe, expect, it, mock } from 'bun:test';
-import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { _resetWorkingDir } from '../../../src/bootstrap/workingDir.js';
-import { ALL_TOOLS } from '../../../src/tools/index.js';
-import { runWorkflow } from '../src/runner.js';
-import type { LoopEvent, Provider } from '../../../src/types.js';
-import type { RunContext, WorkflowDef, WorkflowEvent } from '../src/types.js';
-
-type WfOrLoop = WorkflowEvent | LoopEvent;
-
-const fakeProvider: Provider = {
-  name: 'test',
-  baseURL: '',
-  apiKey: '',
-  model: 'm',
-  contextWindow: 128000,
-};
-
-async function collect(
-  gen: AsyncGenerator<WfOrLoop, void, void>,
-): Promise<WfOrLoop[]> {
-  const out: WfOrLoop[] = [];
-  for await (const ev of gen) out.push(ev);
-  return out;
-}
-
-const STATE_DIR = '.minimal-agent-workflow';
-
-describe('workflow state-dir 生命周期', () => {
-  let tmp: string;
-  let ctx: RunContext;
-
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), 'wf-state-'));
-    process.env.MINIMAL_AGENT_CWD = tmp;
-    _resetWorkingDir();
-    mock.module('../../../src/bootstrap/workingDir.js', () => ({
-      getWorkingDir: () => tmp,
-      initWorkingDir: () => tmp,
-      _resetWorkingDir: () => {},
-    }));
-    ctx = { provider: fakeProvider, history: [], cwd: tmp, tools: ALL_TOOLS };
-  });
-
-  afterEach(() => {
-    delete process.env.MINIMAL_AGENT_CWD;
-    _resetWorkingDir();
-    rmSync(tmp, { recursive: true, force: true });
-  });
-
-  it('干净跑完 → 活动状态目录归档为 <name>.done（E6 后按名隔离）', async () => {
-    const def: WorkflowDef = {
-      name: 'ok',
-      description: 'd',
-      steps: [{ id: 's1', type: 'assert', condition: '1 == 1' }],
-    };
-    const events = await collect(runWorkflow(def, {}, ctx));
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
-    // 成功路径：活动目录被归档改名（completed 检测靠它），不留活动现场
-    expect(existsSync(join(tmp, STATE_DIR, 'ok'))).toBe(false);
-    expect(existsSync(join(tmp, STATE_DIR, 'ok.done'))).toBe(true);
-  });
-
-  it('halt → 保留状态目录 + progress.md 含失败那步', async () => {
-    const def: WorkflowDef = {
-      name: 'boom',
-      description: 'd',
-      steps: [
-        { id: 'will_fail', type: 'assert', condition: '1 == 2', onFail: 'nope' },
-      ],
-    };
-    const events = await collect(runWorkflow(def, {}, ctx));
-    // 确实 halt 了（有 error 事件、没有 workflow_done）
-    expect(events.some((e) => e.type === 'error')).toBe(true);
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(false);
-
-    // 失败现场必须保留，供事后排查
-    const stateDir = join(tmp, STATE_DIR, 'boom');
-    expect(existsSync(stateDir)).toBe(true);
-    const progress = readFileSync(join(stateDir, 'progress.md'), 'utf8');
-    // 失败那步的 ✗ 行 + onFail 文案都应在 progress 里
-    expect(progress).toContain('will_fail');
-    expect(progress).toContain('nope');
-  });
-
-  it('再次运行同名 workflow（同 goal）→ resume 后成功 → 归档不堆积', async () => {
-    const failDef: WorkflowDef = {
-      name: 'rerun',
-      description: 'd',
-      steps: [{ id: 'f', type: 'assert', condition: 'false', onFail: 'x' }],
-    };
-    await collect(runWorkflow(failDef, {}, ctx));
-    expect(existsSync(join(tmp, STATE_DIR, 'rerun'))).toBe(true); // 失败留下了
-
-    // 第二次成功跑（同名同 inputs = 同任务 resume）：成功后归档 → 活动目录干净
-    const okDef: WorkflowDef = {
-      name: 'rerun',
-      description: 'd',
-      steps: [{ id: 'ok', type: 'assert', condition: 'true' }],
-    };
-    await collect(runWorkflow(okDef, {}, ctx));
-    expect(existsSync(join(tmp, STATE_DIR, 'rerun'))).toBe(false); // 不堆积
-    expect(existsSync(join(tmp, STATE_DIR, 'rerun.done'))).toBe(true);
-  });
-
-  it('E6：A 工作流失败现场不被不同名工作流 B 的运行破坏（按名隔离）', async () => {
-    // A 失败留现场 + 留声明产物
-    const aDef: WorkflowDef = {
-      name: 'wf-a',
-      description: 'd',
-      artifacts: ['A-PLAN.md'],
-      steps: [
-        { id: 'w', tool: 'Write', args: { file_path: 'A-PLAN.md', content: 'A 的半成品' } },
-        { id: 'f', type: 'assert', condition: 'false', onFail: 'A 中断' },
-      ],
-    };
-    await collect(runWorkflow(aDef, {}, ctx));
-    expect(existsSync(join(tmp, STATE_DIR, 'wf-a'))).toBe(true);
-    expect(existsSync(join(tmp, 'A-PLAN.md'))).toBe(true);
-
-    // 跑不同名工作流 B（曾经会清掉 A 的状态目录和产物——E6 事故）
-    const bDef: WorkflowDef = {
-      name: 'wf-b',
-      description: 'd',
-      steps: [{ id: 'ok', type: 'assert', condition: 'true' }],
-    };
-    const evB = await collect(runWorkflow(bDef, {}, ctx));
-    expect(evB.some((e) => e.type === 'workflow_done')).toBe(true);
-
-    // A 的现场与产物完好，resume 能力保留
-    expect(existsSync(join(tmp, STATE_DIR, 'wf-a'))).toBe(true);
-    expect(existsSync(join(tmp, 'A-PLAN.md'))).toBe(true);
-  });
-});