minimal-agent 0.13.0 → 0.14.0

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

@@ -1,370 +0,0 @@
-/**
- * ============================================================
- *  test/workflows/e2e.test.ts —— /workflow 端到端测试
- * ------------------------------------------------------------
- *  从用户敲 `/workflow hello-workflow --input ...` 这一最外层入口开始，
- *  穿过：
- *
- *    runWithPlugins
- *      → discoverPlugins (扫到真实 workflow-runner 插件)
- *      → resolveCommand  (识别 /workflow)
- *      → cmd.executionMode === 'workflow' 路径
- *      → lazy import workflows/index.ts
- *      → parseWorkflowArgs + coerceInputs
- *      → findWorkflowByName (从 tmp/workflows/ 加载 fixture)
- *      → runWorkflow → step executors (真实 executeTool('Write'))
- *
- *  断言：
- *    - 整个事件序列形态合理（workflow_start → step_start/end ×N → workflow_done → turn_done）
- *      注：经命令路径（runWithPlugins→runWorkflowFromCommand）成功后补发通用 turn_done 收口，
- *      故终结事件是 turn_done（workflow_done 在其前一条）；直测 runWorkflow 的 runner.test.ts 仍以 workflow_done 收尾
- *    - 文件真的落盘到正确路径，内容正确
- *    - 缺必填 input 时不写任何文件
- *    - assert 失败时整个 workflow halt
- *
- *  不 mock chat / runQuery —— fixture 不依赖 LLM。
- *  只 mock workingDir.ts，因为其它测试文件留下的全局 mock 会污染。
- * ============================================================
- */
-
-import {
-  afterEach,
-  beforeEach,
-  describe,
-  expect,
-  it,
-  mock,
-} from 'bun:test';
-import {
-  copyFileSync,
-  existsSync,
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  rmSync,
-} from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { _resetWorkingDir } from '../../../src/bootstrap/workingDir.js';
-import { _resetPluginCache } from '../../../src/plugins/commandRouter.js';
-import type { LoopEvent, Provider } from '../../../src/types.js';
-import type { PluginEvent } from '../../../src/plugins/pluginApi.js';
-import type { WorkflowEvent } from '../src/types.js';
-
-type WfOrLoop = LoopEvent | PluginEvent | WorkflowEvent;
-
-const FIXTURE_SRC = join(import.meta.dir, 'fixtures', 'hello-workflow.yaml');
-
-const provider: 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 as WfOrLoop);
-  return out;
-}
-
-describe('workflow E2E（/workflow → 路由 → runner → 文件落盘）', () => {
-  let tmp: string;
-
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), 'wf-e2e-'));
-    mkdirSync(join(tmp, 'workflows'), { recursive: true });
-    copyFileSync(FIXTURE_SRC, join(tmp, 'workflows', 'hello-workflow.yaml'));
-
-    process.env.MINIMAL_AGENT_CWD = tmp;
-    _resetWorkingDir();
-    _resetPluginCache();
-
-    // 抵抗其它测试文件留下的 workingDir.ts 全局 mock 污染。
-    // 注：这一行让 getWorkingDir 跟着 tmp 走，相对路径锚点 + workflows/ 双源扫描都受益。
-    mock.module('../../../src/bootstrap/workingDir.js', () => ({
-      getWorkingDir: () => tmp,
-      initWorkingDir: () => tmp,
-      _resetWorkingDir: () => {},
-    }));
-  });
-
-  afterEach(() => {
-    delete process.env.MINIMAL_AGENT_CWD;
-    _resetWorkingDir();
-    _resetPluginCache();
-    rmSync(tmp, { recursive: true, force: true });
-  });
-
-  async function runCmd(input: string): Promise<WfOrLoop[]> {
-    const { runWithPlugins } = await import('../../../src/plugins/pluginRunner.js');
-    return collect(
-      runWithPlugins(input, { provider, history: [] }) as AsyncGenerator<WfOrLoop, void, void>,
-    );
-  }
-
-  it('golden path：/workflow hello-workflow --input name=alice --input lang=zh 跑完且文件落盘', async () => {
-    const events = await runCmd('/workflow hello-workflow --input name=alice --input lang=zh');
-
-    // 整体形态
-    expect(events[0]?.type).toBe('workflow_start');
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
-    // 命令路径（runWorkflowFromCommand）成功后补发通用 turn_done 作终结事件（对外协议收口），
-    // 故 turn_done 是最后一条、workflow_done 在其前一条。直测 runWorkflow 的 runner.test.ts 仍以 workflow_done 收尾。
-    expect(events[events.length - 1]?.type).toBe('turn_done');
-    expect(events.some((e) => e.type === 'error')).toBe(false);
-
-    // 每个 step 都跑完且 ok=true
-    const ends = events.filter(
-      (e): e is Extract<WorkflowEvent, { type: 'workflow_step_end' }> => e.type === 'workflow_step_end',
-    );
-    expect(ends.length).toBe(4);
-    expect(ends.every((e) => e.ok)).toBe(true);
-    expect(ends.map((e) => e.id)).toEqual([
-      'write_greeting',
-      'write_meta',
-      'verify_files',
-      'verify_capture',
-    ]);
-
-    // 文件实际写盘
-    const helloPath = join(tmp, 'greetings', 'alice', 'hello.txt');
-    const metaPath = join(tmp, 'greetings', 'alice', 'meta.json');
-    expect(existsSync(helloPath)).toBe(true);
-    expect(existsSync(metaPath)).toBe(true);
-
-    // hello.txt 内容验证（${var} 插值确实工作了）
-    expect(readFileSync(helloPath, 'utf8')).toBe('Hello, alice! (lang=zh)');
-
-    // meta.json 是合法 JSON，字段对得上
-    const meta = JSON.parse(readFileSync(metaPath, 'utf8'));
-    expect(meta.name).toBe('alice');
-    expect(meta.lang).toBe('zh');
-    // length() 内置函数 + capture 链路：greeting_text="Hello, alice! (lang=zh)" → 长度 23
-    expect(meta.greeting_length).toBe('Hello, alice! (lang=zh)'.length);
-  });
-
-  it('lang 使用默认值 en（input enum default 路径）', async () => {
-    const events = await runCmd('/workflow hello-workflow --input name=bob');
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
-    // 命令路径（runWorkflowFromCommand）成功后补发通用 turn_done 作终结事件（对外协议收口），
-    // 故 turn_done 是最后一条、workflow_done 在其前一条。直测 runWorkflow 的 runner.test.ts 仍以 workflow_done 收尾。
-    expect(events[events.length - 1]?.type).toBe('turn_done');
-    expect(readFileSync(join(tmp, 'greetings', 'bob', 'hello.txt'), 'utf8'))
-      .toBe('Hello, bob! (lang=en)');
-  });
-
-  it('workflow_step_start 事件 index/total 单调且与 yaml 一致', async () => {
-    const events = await runCmd('/workflow hello-workflow --input name=carol');
-    const starts = events.filter(
-      (e): e is Extract<WorkflowEvent, { type: 'workflow_step_start' }> => e.type === 'workflow_step_start',
-    );
-    expect(starts.length).toBe(4);
-    expect(starts.map((s) => s.index)).toEqual([0, 1, 2, 3]);
-    expect(starts.every((s) => s.total === 4)).toBe(true);
-    expect(starts.map((s) => s.kind)).toEqual(['tool', 'tool', 'assert', 'assert']);
-  });
-
-  it('缺必填 input name → yield error，且没写任何文件', async () => {
-    const events = await runCmd('/workflow hello-workflow');
-    expect(events.some((e) => e.type === 'error')).toBe(true);
-    expect(events.some((e) => e.type === 'workflow_start')).toBe(false);
-    // tmp/greetings/ 不应被创建
-    expect(existsSync(join(tmp, 'greetings'))).toBe(false);
-  });
-
-  it('lang 传非法值 → yield enum 校验 error，且不进入 runWorkflow', async () => {
-    const events = await runCmd('/workflow hello-workflow --input name=dave --input lang=fr');
-    const err = events.find(
-      (e): e is Extract<LoopEvent, { type: 'error' }> => e.type === 'error',
-    );
-    expect(err).toBeDefined();
-    expect(err!.error).toContain('lang');
-    expect(events.some((e) => e.type === 'workflow_start')).toBe(false);
-  });
-
-  it('未知 workflow 名 → yield error，不污染文件系统', async () => {
-    const events = await runCmd('/workflow definitely-not-exists --input name=eve');
-    expect(events.some((e) => e.type === 'error')).toBe(true);
-    expect(events.some((e) => e.type === 'workflow_start')).toBe(false);
-    expect(existsSync(join(tmp, 'greetings'))).toBe(false);
-  });
-
-  it('L2：位置参数等价 --input —— /workflow hello-workflow alice 同效', async () => {
-    const events = await runCmd('/workflow hello-workflow alice');
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
-    // 命令路径（runWorkflowFromCommand）成功后补发通用 turn_done 作终结事件（对外协议收口），
-    // 故 turn_done 是最后一条、workflow_done 在其前一条。直测 runWorkflow 的 runner.test.ts 仍以 workflow_done 收尾。
-    expect(events[events.length - 1]?.type).toBe('turn_done');
-    // lang 走 default=en
-    expect(readFileSync(join(tmp, 'greetings', 'alice', 'hello.txt'), 'utf8'))
-      .toBe('Hello, alice! (lang=en)');
-  });
-
-  it('L2：多个位置参数按 inputs 声明顺序映射 —— alice zh → name=alice, lang=zh', async () => {
-    const events = await runCmd('/workflow hello-workflow alice zh');
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
-    // 命令路径（runWorkflowFromCommand）成功后补发通用 turn_done 作终结事件（对外协议收口），
-    // 故 turn_done 是最后一条、workflow_done 在其前一条。直测 runWorkflow 的 runner.test.ts 仍以 workflow_done 收尾。
-    expect(events[events.length - 1]?.type).toBe('turn_done');
-    expect(readFileSync(join(tmp, 'greetings', 'alice', 'hello.txt'), 'utf8'))
-      .toBe('Hello, alice! (lang=zh)');
-  });
-
-  it('L2：.yaml / .yml 后缀自动剥离 —— hello-workflow.yaml alice 与 hello-workflow alice 等价', async () => {
-    const events = await runCmd('/workflow hello-workflow.yaml alice');
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
-    // 命令路径（runWorkflowFromCommand）成功后补发通用 turn_done 作终结事件（对外协议收口），
-    // 故 turn_done 是最后一条、workflow_done 在其前一条。直测 runWorkflow 的 runner.test.ts 仍以 workflow_done 收尾。
-    expect(events[events.length - 1]?.type).toBe('turn_done');
-    expect(existsSync(join(tmp, 'greetings', 'alice', 'hello.txt'))).toBe(true);
-  });
-
-  it('L2：--input 优先级高于位置参数 —— 同槽位的位置参数被丢弃但会 yield warning', async () => {
-    // rawInputs={name:'bob'} (来自 --input)；positional=['alice'] 对应 inputs[0]=name (已占) → 丢弃 + warn
-    // 最终 name=bob, lang=default(en)
-    const events = await runCmd('/workflow hello-workflow alice --input name=bob');
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
-    // 命令路径（runWorkflowFromCommand）成功后补发通用 turn_done 作终结事件（对外协议收口），
-    // 故 turn_done 是最后一条、workflow_done 在其前一条。直测 runWorkflow 的 runner.test.ts 仍以 workflow_done 收尾。
-    expect(events[events.length - 1]?.type).toBe('turn_done');
-    expect(existsSync(join(tmp, 'greetings', 'bob'))).toBe(true);
-    expect(existsSync(join(tmp, 'greetings', 'alice'))).toBe(false);
-    expect(readFileSync(join(tmp, 'greetings', 'bob', 'hello.txt'), 'utf8'))
-      .toBe('Hello, bob! (lang=en)');
-
-    // 必须有一条 warning 提示位置参数被覆盖
-    const warn = events.find(
-      (e): e is { type: 'warning'; message: string } => e.type === 'warning',
-    );
-    expect(warn).toBeDefined();
-    expect(warn!.message).toContain('被覆盖');
-    expect(warn!.message).toContain('alice');
-    expect(warn!.message).toContain('name');
-  });
-
-  it('L2：位置 + --input 混用 —— 位置填 name，--input 填 lang', async () => {
-    // 位置 alice 填 name；--input lang=zh 填 lang（不冲突）
-    const events = await runCmd('/workflow hello-workflow alice --input lang=zh');
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
-    // 命令路径（runWorkflowFromCommand）成功后补发通用 turn_done 作终结事件（对外协议收口），
-    // 故 turn_done 是最后一条、workflow_done 在其前一条。直测 runWorkflow 的 runner.test.ts 仍以 workflow_done 收尾。
-    expect(events[events.length - 1]?.type).toBe('turn_done');
-    expect(readFileSync(join(tmp, 'greetings', 'alice', 'hello.txt'), 'utf8'))
-      .toBe('Hello, alice! (lang=zh)');
-  });
-
-  it('L2：多余的位置参数被丢弃但会 yield warning（不影响执行）', async () => {
-    // 第 3、4 个位置参数 extra1/extra2 没有 input 槽位 → 丢弃 + warn
-    const events = await runCmd('/workflow hello-workflow alice zh extra1 extra2');
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
-    // 命令路径（runWorkflowFromCommand）成功后补发通用 turn_done 作终结事件（对外协议收口），
-    // 故 turn_done 是最后一条、workflow_done 在其前一条。直测 runWorkflow 的 runner.test.ts 仍以 workflow_done 收尾。
-    expect(events[events.length - 1]?.type).toBe('turn_done');
-    expect(readFileSync(join(tmp, 'greetings', 'alice', 'hello.txt'), 'utf8'))
-      .toBe('Hello, alice! (lang=zh)');
-
-    // 必须有一条 warning 提示多余参数被忽略，且列出具体值
-    const warn = events.find(
-      (e): e is { type: 'warning'; message: string } => e.type === 'warning',
-    );
-    expect(warn).toBeDefined();
-    expect(warn!.message).toContain('忽略了 2 个');
-    expect(warn!.message).toContain('extra1');
-    expect(warn!.message).toContain('extra2');
-  });
-
-  it('L2：位置参数刚好等于 inputs 数量 —— 无 warning', async () => {
-    // alice zh 正好填满 name + lang，无超量、无覆盖 → 不应有 warning
-    const events = await runCmd('/workflow hello-workflow alice zh');
-    expect(events.some((e) => e.type === 'warning')).toBe(false);
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
-    // 命令路径（runWorkflowFromCommand）成功后补发通用 turn_done 作终结事件（对外协议收口），
-    // 故 turn_done 是最后一条、workflow_done 在其前一条。直测 runWorkflow 的 runner.test.ts 仍以 workflow_done 收尾。
-    expect(events[events.length - 1]?.type).toBe('turn_done');
-  });
-
-  it('/workflows 列表能看到 hello-workflow（cwd 优先双源加载）', async () => {
-    const events = await runCmd('/workflows');
-    const text = events
-      .filter((e): e is Extract<LoopEvent, { type: 'text' }> => e.type === 'text')
-      .map((e) => e.delta)
-      .join('');
-    expect(text).toContain('hello-workflow');
-  });
-});
-
-describe('workflow E2E：assert 失败 → halt（用变体 fixture）', () => {
-  let tmp: string;
-
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), 'wf-e2e-fail-'));
-    mkdirSync(join(tmp, 'workflows'), { recursive: true });
-    // 写一个故意 assert 不通过的 yaml
-    const failYaml = `name: assert-fail-fixture
-description: assert 必失败的端到端 fixture
-steps:
-  - id: write_a
-    tool: Write
-    args:
-      file_path: "a.txt"
-      content: "hi"
-  - id: bad_assert
-    type: assert
-    condition: '1 == 2'
-    onFail: "故意失败"
-  - id: should_not_run
-    tool: Write
-    args:
-      file_path: "b.txt"
-      content: "should not exist"
-`;
-    require('node:fs').writeFileSync(
-      join(tmp, 'workflows', 'assert-fail-fixture.yaml'),
-      failYaml,
-      'utf8',
-    );
-
-    process.env.MINIMAL_AGENT_CWD = tmp;
-    _resetWorkingDir();
-    _resetPluginCache();
-    mock.module('../../../src/bootstrap/workingDir.js', () => ({
-      getWorkingDir: () => tmp,
-      initWorkingDir: () => tmp,
-      _resetWorkingDir: () => {},
-    }));
-  });
-
-  afterEach(() => {
-    delete process.env.MINIMAL_AGENT_CWD;
-    _resetWorkingDir();
-    _resetPluginCache();
-    rmSync(tmp, { recursive: true, force: true });
-  });
-
-  it('assert 失败 → 后续 step 不执行 + yield error + 没 workflow_done', async () => {
-    const { runWithPlugins } = await import('../../../src/plugins/pluginRunner.js');
-    const events = await collect(
-      runWithPlugins('/workflow assert-fail-fixture', { provider, history: [] }),
-    );
-
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(false);
-    expect(events.some((e) => e.type === 'error')).toBe(true);
-
-    // a.txt 在 assert 前就写盘，应存在
-    expect(existsSync(join(tmp, 'a.txt'))).toBe(true);
-    // b.txt 在 assert 后，不应被写
-    expect(existsSync(join(tmp, 'b.txt'))).toBe(false);
-
-    // 错误信息含 onFail 自定义文案
-    const errs = events
-      .filter((e): e is Extract<LoopEvent, { type: 'error' }> => e.type === 'error')
-      .map((e) => e.error)
-      .join('\n');
-    expect(errs).toContain('故意失败');
-  });
-});

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

@@ -1,314 +0,0 @@
-/**
- * 端到端验证 Phase 3：session 化状态目录布局（<wfDir>/<sessionId>/）
- * 在真实 runWorkflow 下的完整行为：fresh → 同 goal completed →
- * 不同 goal new-task + 归档 → 旧布局兼容 → 多 session 并行隔离。
- *
- * 复用 e2e.test.ts 的 mock 模式（mock workingDir.ts + MINIMAL_AGENT_CWD），
- * 用 hello-workflow fixture（无 LLM 依赖，确定性强）。
- */
-import {
-  afterEach,
-  beforeEach,
-  describe,
-  expect,
-  it,
-  mock,
-} from 'bun:test';
-import {
-  copyFileSync,
-  existsSync,
-  mkdirSync,
-  mkdtempSync,
-  readdirSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-} from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { _resetWorkingDir } from '../../../src/bootstrap/workingDir.js';
-import { _resetPluginCache } from '../../../src/plugins/commandRouter.js';
-import type { Provider } from '../../../src/types.js';
-import type { PluginEvent } from '../../../src/plugins/pluginApi.js';
-import type { WorkflowEvent } from '../src/types.js';
-
-type Ev = PluginEvent | WorkflowEvent;
-
-const FIXTURE_SRC = join(import.meta.dir, 'fixtures', 'hello-workflow.yaml');
-
-const provider: Provider = {
-  name: 'test',
-  baseURL: '',
-  apiKey: '',
-  model: 'm',
-  contextWindow: 128000,
-};
-
-async function collect(gen: AsyncGenerator<Ev, void, void>): Promise<Ev[]> {
-  const out: Ev[] = [];
-  for await (const ev of gen) out.push(ev);
-  return out;
-}
-
-const SESSION_ALPHA = 'alpha';
-const SESSION_BETA = 'beta';
-
-describe('workflow E2E · session 化新布局（Phase 3）', () => {
-  let tmp: string;
-
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), 'wf-e2e-phase3-'));
-    mkdirSync(join(tmp, 'workflows'), { recursive: true });
-    // 拷贝 fixture 并：① 加 goal input（hash 身份的关键字段，区分任务）
-    // ② 补静态路径 artifacts 声明 + 一个写它的 step（new-task 归档逻辑依赖声明产物；
-    //    注意 artifacts 不支持 ${var} 插值，必须用固定路径）
-    const raw = readFileSync(FIXTURE_SRC, 'utf8');
-    const patched = raw
-      .replace(
-        'version: "0.1"',
-        'version: "0.1"\n\nartifacts:\n  - "greetings/output.txt"',
-      )
-      .replace(
-        'inputs:\n  - name: name',
-        'inputs:\n  - name: goal\n    type: string\n    required: true\n    description: 任务身份\n  - name: name',
-      )
-      // 在 verify_files 前插一个写 output.txt 的 step
-      .replace(
-        '  - id: verify_files',
-        `  - id: write_output\n    tool: Write\n    args:\n      file_path: "greetings/output.txt"\n      content: "ok"\n\n  - id: verify_files`,
-      );
-    writeFileSync(join(tmp, 'workflows', 'hello-workflow.yaml'), patched);
-
-    process.env.MINIMAL_AGENT_CWD = tmp;
-    _resetWorkingDir();
-    _resetPluginCache();
-    mock.module('../../../src/bootstrap/workingDir.js', () => ({
-      getWorkingDir: () => tmp,
-      initWorkingDir: () => tmp,
-      _resetWorkingDir: () => {},
-    }));
-  });
-
-  afterEach(() => {
-    delete process.env.MINIMAL_AGENT_CWD;
-    _resetWorkingDir();
-    _resetPluginCache();
-    rmSync(tmp, { recursive: true, force: true });
-  });
-
-  async function runCmd(
-    input: string,
-    opts: { sessionId?: string } = {},
-  ): Promise<Ev[]> {
-    const { runWithPlugins } = await import('../../../src/plugins/pluginRunner.js');
-    const runtimeContext: Record<string, unknown> = {};
-    if (opts.sessionId) runtimeContext.sessionId = opts.sessionId;
-    return collect(runWithPlugins(input, {
-      provider,
-      history: [],
-      runtimeContext: runtimeContext as any,
-    }) as AsyncGenerator<Ev>);
-  }
-
-  function wfDir(): string {
-    return join(tmp, '.minimal-agent-workflow', 'hello-workflow');
-  }
-
-  function sessionActive(session: string): boolean {
-    return existsSync(join(wfDir(), session));
-  }
-  function sessionDone(session: string): boolean {
-    return existsSync(join(wfDir(), `${session}.done`));
-  }
-  function sessionTrash(session: string): boolean {
-    return existsSync(join(wfDir(), `${session}.trash`));
-  }
-
-  it('fresh → 真实 runWorkflow 跑完归档到 <wfDir>/<sessionId>.done/（成功路径）', async () => {
-    await runCmd(
-      '/workflow hello-workflow --input goal=任务A --input name=alice --input lang=en',
-      { sessionId: SESSION_BETA },
-    );
-
-    // 跑完后状态被 archive，活动实例目录被改名 <sessionId>.done/
-    expect(sessionActive(SESSION_BETA)).toBe(false);
-    expect(sessionDone(SESSION_BETA)).toBe(true);
-    // 产物实际落盘到 cwd（不是状态目录里）
-    expect(existsSync(join(tmp, 'greetings/alice/hello.txt'))).toBe(true);
-    // 状态目录保留了 current.json / inputs.json / progress.md 等（供后续回溯）
-    const doneDir = join(wfDir(), `${SESSION_BETA}.done`);
-    expect(existsSync(join(doneDir, 'current.json'))).toBe(true);
-  });
-
-  it('未指定 sessionId → 引擎自动生成唯一 session（非 default），多 session 互不覆盖', async () => {
-    // 不传 sessionId：宿主未提供有意义 session（runtimeContext.sessionId 缺失），
-    // 引擎应自动命名一个唯一 session（YYYYMMDD-HHmmss-xxxxxx），而非固定 'default'
-    await runCmd(
-      '/workflow hello-workflow --input goal=任务A --input name=alice --input lang=en',
-    );
-    let doneEntries = readdirSync(wfDir()).filter((n) => n.endsWith('.done'));
-    expect(doneEntries.length).toBe(1);
-    const autoSession = doneEntries[0].slice(0, -'.done'.length);
-    expect(autoSession).not.toBe('default');
-    expect(/^\d{8}-\d{6}-[0-9a-f]{6}$/.test(autoSession)).toBe(true);
-    // 产物落盘
-    expect(existsSync(join(tmp, 'greetings/alice/hello.txt'))).toBe(true);
-
-    // 再跑一次（不同 goal）：引擎自动生成第二个独立 session，各自归档互不覆盖
-    await runCmd(
-      '/workflow hello-workflow --input goal=任务X --input name=carol --input lang=en',
-    );
-    doneEntries = readdirSync(wfDir()).filter((n) => n.endsWith('.done'));
-    expect(doneEntries.length).toBe(2);
-  });
-
-  it('fresh + 同 goal 再跑 → completed（命中 .done/ 归档，第二次不写产物）', async () => {
-    await runCmd(
-      '/workflow hello-workflow --input goal=任务A --input name=alice --input lang=en',
-      { sessionId: SESSION_BETA },
-    );
-    expect(sessionDone(SESSION_BETA)).toBe(true);
-
-    const events = await runCmd(
-      '/workflow hello-workflow --input goal=任务A --input name=alice --input lang=en',
-      { sessionId: SESSION_BETA },
-    );
-
-    // 第二次是 completed：.done 归档不变（同一任务已完成，不重新归档）
-    expect(sessionActive(SESSION_BETA)).toBe(false);
-    expect(sessionDone(SESSION_BETA)).toBe(true);
-    // 产物保留（completed 不删）
-    expect(existsSync(join(tmp, 'greetings/alice/hello.txt'))).toBe(true);
-    // 事件序列表明已完成分支被命中
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
-  });
-
-  it('goal A 完成 → 改 goal B（同 session 内 new-task）：B 产物覆盖，A 产物归档到 .trash/<stamp>/', async () => {
-    await runCmd(
-      '/workflow hello-workflow --input goal=任务A --input name=alice --input lang=en',
-      { sessionId: SESSION_BETA },
-    );
-    expect(sessionDone(SESSION_BETA)).toBe(true);
-    expect(existsSync(join(tmp, 'greetings/output.txt'))).toBe(true);
-
-    // 改 goal → hash 不同 → new-task（同 session 内，A 被归档后重跑 B）
-    await runCmd(
-      '/workflow hello-workflow --input goal=任务B --input name=bob --input lang=zh',
-      { sessionId: SESSION_BETA },
-    );
-
-    // 最终仍是 .done（B 成功）
-    expect(sessionActive(SESSION_BETA)).toBe(false);
-    expect(sessionDone(SESSION_BETA)).toBe(true);
-    // B 产物存在
-    expect(existsSync(join(tmp, 'greetings/bob/hello.txt'))).toBe(true);
-    // 声明产物（output.txt）被 goal B 重新生成（write_output step 又跑了一遍）
-    expect(existsSync(join(tmp, 'greetings/output.txt'))).toBe(true);
-    // A 的旧产物被归档到 .trash 里（goal A 的旧 output.txt）
-    const trashDir = join(wfDir(), `${SESSION_BETA}.trash`);
-    expect(sessionTrash(SESSION_BETA)).toBe(true);
-    const outputInTrash = flattenDir(trashDir).some((f) =>
-      f.endsWith('output.txt'),
-    );
-    expect(outputInTrash).toBe(true);
-  });
-
-  it('同 goal 两个 session → 各自独立完成（Phase 3 核心：多 session 并行隔离）', async () => {
-    // session alpha 跑 goal=任务A
-    await runCmd(
-      '/workflow hello-workflow --input goal=任务A --input name=alice --input lang=en',
-      { sessionId: SESSION_ALPHA },
-    );
-    // session beta 跑 goal=任务A（同 goal，不同 session）
-    await runCmd(
-      '/workflow hello-workflow --input goal=任务A --input name=alice --input lang=en',
-      { sessionId: SESSION_BETA },
-    );
-
-    // 两个 session 都有自己的 .done 归档，互不干扰
-    expect(sessionDone(SESSION_ALPHA)).toBe(true);
-    expect(sessionDone(SESSION_BETA)).toBe(true);
-    // 各自的 current.json 都在
-    expect(existsSync(join(wfDir(), `${SESSION_ALPHA}.done`, 'current.json'))).toBe(true);
-    expect(existsSync(join(wfDir(), `${SESSION_BETA}.done`, 'current.json'))).toBe(true);
-    // 产物（共享 cwd 下）都存在
-    expect(existsSync(join(tmp, 'greetings/alice/hello.txt'))).toBe(true);
-    expect(existsSync(join(tmp, 'greetings/output.txt'))).toBe(true);
-  });
-
-  it('不同 session 的 new-task 互不影响：A session 跑 goalA，B session 跑 goalB 时 A 完好', async () => {
-    // session alpha: goalA 完成
-    await runCmd(
-      '/workflow hello-workflow --input goal=任务A --input name=alice --input lang=en',
-      { sessionId: SESSION_ALPHA },
-    );
-    expect(sessionDone(SESSION_ALPHA)).toBe(true);
-    const alphaBefore = readFileSync(
-      join(wfDir(), `${SESSION_ALPHA}.done`, 'current.json'),
-      'utf8',
-    );
-
-    // session beta: 跑 goalB（new-task，不应碰 alpha 的任何东西）
-    await runCmd(
-      '/workflow hello-workflow --input goal=任务B --input name=bob --input lang=zh',
-      { sessionId: SESSION_BETA },
-    );
-
-    // alpha 的 .done 完好无损
-    expect(sessionDone(SESSION_ALPHA)).toBe(true);
-    const alphaAfter = readFileSync(
-      join(wfDir(), `${SESSION_ALPHA}.done`, 'current.json'),
-      'utf8',
-    );
-    expect(alphaAfter).toBe(alphaBefore);
-    // alpha 的产物归档（.trash）也没被 beta session 碰
-    // beta 自己的 .done 也有了
-    expect(sessionDone(SESSION_BETA)).toBe(true);
-  });
-
-  it('旧布局状态文件（wfDir/current.json）→ 新引擎正确识别 + 处理（兼容）', async () => {
-    // 手写旧布局状态（status=running，未完成）
-    mkdirSync(wfDir(), { recursive: true });
-    writeFileSync(
-      join(wfDir(), 'current.json'),
-      JSON.stringify({
-        name: 'hello-workflow',
-        taskId: '1234567890abcdef',
-        status: 'running',
-        startedAt: '2026-01-01T00:00:00.000Z',
-        artifacts: [],
-        defFingerprint: 'legacy',
-      }),
-    );
-
-    // 跑真实工作流：新引擎应当从旧布局读到状态，根据 hash 走对应分支
-    const events = await runCmd(
-      '/workflow hello-workflow --input goal=任务C --input name=carol --input lang=en',
-      { sessionId: SESSION_BETA },
-    );
-
-    // 核心断言：新引擎成功处理（无 error），最终有归档或活动实例
-    expect(events.filter((e) => e.type === 'error').length).toBe(0);
-    expect(sessionDone(SESSION_BETA) || sessionActive(SESSION_BETA)).toBe(true);
-    // carol 产物落盘
-    expect(existsSync(join(tmp, 'greetings/carol/hello.txt'))).toBe(true);
-  });
-});
-
-/** 递归列出目录下所有文件路径 */
-function flattenDir(dir: string): string[] {
-  const out: string[] = [];
-  const walk = (d: string) => {
-    for (const e of readdirSync(d)) {
-      const p = join(d, e);
-      const isDir = existsSync(p) && (() => {
-        try { readdirSync(p); return true; } catch { return false; }
-      })();
-      if (isDir) walk(p);
-      else out.push(p);
-    }
-  };
-  walk(dir);
-  return out;
-}