minimal-agent 0.13.0 → 0.14.0

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

@@ -1,198 +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, readdirSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { _resetWorkingDir } from '../../../src/bootstrap/workingDir.js';
-import { createAgentRuntimeContext } from '../../../src/plugin-sdk.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';
-// 集成测试统一用显式 sessionId（引擎对未指定 session 自动命名，见 runner 的
-// generateDefaultSessionId；测目录生命周期需要可预测的 session 名）
-const SESSION = 'test-session';
-
-function findInstanceDir(base: string, wfName: string, suffix = ''): string | null {
-  const wfDir = join(base, STATE_DIR, wfName);
-  if (!existsSync(wfDir)) {
-    // 旧布局兼容：wfDir 本身就是实例目录（wfName.done 形式）
-    const legacyDir = suffix
-      ? join(base, STATE_DIR, wfName + suffix)
-      : wfDir;
-    if (existsSync(legacyDir)) return legacyDir;
-    return null;
-  }
-
-  // Phase 3：session 化——实例目录名 = sessionId
-  const sessionDir = suffix
-    ? join(wfDir, SESSION + suffix)
-    : join(wfDir, SESSION);
-  if (existsSync(sessionDir)) return sessionDir;
-
-  // 旧布局兼容：wfDir 本身有 current.json（无子实例目录时判定为 legacy）
-  if (!suffix && existsSync(join(wfDir, 'current.json'))) {
-    try {
-      const entries = readdirSync(wfDir, { withFileTypes: true });
-      const hasInstanceSubdir = entries.some(
-        (e) => e.isDirectory() && /^[0-9a-f]{16}$/.test(e.name),
-      );
-      if (!hasInstanceSubdir) return wfDir;
-    } catch {
-      return wfDir;
-    }
-  }
-  return null;
-}
-
-function hasInstance(base: string, wfName: string, suffix = ''): boolean {
-  return findInstanceDir(base, wfName, suffix) !== null;
-}
-
-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,
-      // 显式 sessionId：目录名可预测，resume/归档断言稳定
-      runtimeContext: createAgentRuntimeContext({ surface: 'workflow', profile: 'main', cwd: tmp, sessionId: SESSION, owner: 'local-owner', interactiveAsk: false }),
-    };
-  });
-
-  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(hasInstance(tmp, 'ok')).toBe(false);
-    expect(hasInstance(tmp, '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 = findInstanceDir(tmp, 'boom');
-    expect(stateDir).not.toBeNull();
-    expect(stateDir).toBeDefined();
-    const progress = readFileSync(join(stateDir as string, '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(hasInstance(tmp, '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(hasInstance(tmp, 'rerun')).toBe(false); // 不堆积
-    expect(hasInstance(tmp, '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(hasInstance(tmp, '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(hasInstance(tmp, 'wf-a')).toBe(true);
-    expect(existsSync(join(tmp, 'A-PLAN.md'))).toBe(true);
-  });
-});

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

@@ -1,114 +0,0 @@
-/**
- * ============================================================
- *  stepPipeline —— 「提交一步」的单一实现 + 顺带修正的静默失效
- * ------------------------------------------------------------
- *  重构前这套动作（绑 capture → 写 progress → 落 vars → 记 checkpoint → 发 step_end）
- *  被 `runSteps` 的各内联块各抄一份：recordCheckpoint ×7、appendProgress ×17、
- *  step_end ×19。抄多份的直接后果是漂移 —— 其中 `echo` / `set` 干脆**从不调
- *  `bindCapture`**：yaml 写了 `capture:` 既不报错也不生效，resume 也回放不出来。
- *
- *  搬进执行器体系后它们走统一流水线，capture 自然生效。这里钉住这个修正，
- *  以及「不许再抄第二份流水线」这条结构约束。
- * ============================================================
- */
-
-import { describe, expect, mock, test } from 'bun:test';
-import { mkdtempSync, readFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { runWorkflow } from '../src/runner.js';
-import type { Provider } from '../../../src/types.js';
-import type { RunContext, WorkflowDef, WorkflowEvent } from '../src/types.js';
-
-mock.module('../../../src/llm/client.js', () => ({
-  chat: async function* () {
-    yield { type: 'text_delta', delta: 'ok' };
-    yield { type: 'done', stopReason: 'stop' };
-  },
-}));
-
-const provider: Provider = {
-  name: 't', baseURL: '', apiKey: '', model: 'm', contextWindow: 128000,
-};
-
-/**
- * ⚠️ **工作流名必须每次运行唯一。**
- *
- * 工作流状态目录锚的是 `getWorkingDir()`（进程级），**不是** `RunContext.cwd` ——
- * 见 `runner.ts` 里 `new WorkflowState(getWorkingDir(), def.name)`。
- * 所以给 ctx 传一个 mkdtemp 目录**隔离不了状态**：同名工作流第二次跑会命中
- * 「同名任务此前已完成」而**整条短路**，`workflow_done` 照发、步骤一个不跑 ——
- * 于是断言全部空过，测试在两种实现下都绿，什么都证明不了。
- *
- * 实测踩到：本文件的两条 capture 断言曾在「注入旧行为」时依然全绿，
- * 查下去才发现根本没执行到被测代码。用唯一名根治。
- */
-function uniqueName(base: string): string {
-  return `${base}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-}
-
-async function run(def: WorkflowDef): Promise<WorkflowEvent[]> {
-  const ctx = {
-    provider,
-    history: [{ role: 'system', content: 'sys' }],
-    cwd: mkdtempSync(join(tmpdir(), 'wf-pipeline-')),
-  } as unknown as RunContext;
-  const out: WorkflowEvent[] = [];
-  for await (const e of runWorkflow(def, {}, ctx)) out.push(e as WorkflowEvent);
-  return out;
-}
-
-describe('★ 修正：echo / set 的 capture 从静默失效变为生效', () => {
-  test('echo 带 capture → 变量真的被绑上，下游 assert 能用', async () => {
-    const events = await run({
-      name: uniqueName('echo-capture'),
-      steps: [
-        { id: 'say', type: 'echo', message: 'HELLO', capture: { text: 'said' } },
-        { id: 'check', type: 'assert', condition: "said == 'HELLO'" },
-      ],
-    } as never);
-    // 重构前：echo 从不调 bindCapture → said 为 undefined → assert 判假 → halted
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
-  });
-
-  test('set 带 capture → 别名变量也被绑上', async () => {
-    const events = await run({
-      name: uniqueName('set-capture'),
-      steps: [
-        { id: 'init', type: 'set', set: { phase: 'PLAN' }, capture: { phase: 'alias' } },
-        { id: 'check', type: 'assert', condition: "alias == 'PLAN'" },
-      ],
-    } as never);
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
-  });
-});
-
-describe('★ 结构约束：流水线只许有一份实现', () => {
-  const runnerSrc = readFileSync(
-    join(import.meta.dir, '..', 'src', 'runner.ts'),
-    'utf8',
-  );
-
-  test('runner.ts 不再自己记 checkpoint / 发 step_end（都走 stepPipeline）', () => {
-    // 重构前：recordCheckpoint ×7、appendProgress ×17、step_end ×19
-    expect((runnerSrc.match(/state\.recordCheckpoint\(/g) ?? []).length).toBe(0);
-    expect((runnerSrc.match(/type: 'workflow_step_end'/g) ?? []).length).toBeLessThanOrEqual(2);
-  });
-
-  test('runSteps 保持精简（控制流已搬进 controlFlow/）', () => {
-    const lines = runnerSrc.split('\n');
-    const s = lines.findIndex((l) => l.startsWith('async function* runSteps('));
-    const e = lines.findIndex((l, i) => i > s && l === '}');
-    expect(e - s + 1).toBeLessThanOrEqual(200); // 重构前 780
-  });
-
-  test('★ controlFlow/ 不反向 import runner —— 靠注入的 runBlock', () => {
-    for (const f of ['loop', 'branch', 'pause', 'signal', 'types']) {
-      const src = readFileSync(
-        join(import.meta.dir, '..', 'src', 'controlFlow', `${f}.ts`),
-        'utf8',
-      );
-      expect(src).not.toContain("from '../runner.js'");
-    }
-  });
-});

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

@@ -1,354 +0,0 @@
-/**
- * ============================================================
- *  plugins/workflow-runner/test/taskArbitration.test.ts
- * ------------------------------------------------------------
- *  任务身份语义仲裁层（hash 不等 + 旧任务未完成时的二审）契约：
- *
- *  hash 仍是同任务的权威信号（相等 → resume/completed）。hash 不等且旧任务
- *  未完成时不再一票否决 new-task，仲裁链逐级降级：
- *    a. 延续短语快路径（继续/接着/continue…）→ resume，不花 LLM
- *    b. LLM 单轮仲裁（JSON verdict）→ resume / new 决断
- *    c. unsure / LLM 不可用 → AskUserQuestion（非交互自动选推荐项=全新开始）
- *    d. 提问也失败 → 兜底 new-task（= 旧红线行为）
- *
- *  仲裁判定 resume 时：旧任务状态/产物保留、从断点续跑，goalAnchor 锚旧目标
- *  + 新输入作补充指令（不能让每步 LLM 把「继续」当成目标）。
- *
- *  约定：DI 注入（chat / executeTool stub），禁 mock.module(client/loop/plugin-sdk)。
- * ============================================================
- */
-
-import { afterEach, beforeEach, describe, expect, it, mock } from 'bun:test';
-import { existsSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { _resetWorkingDir } from '../../../src/bootstrap/workingDir.js';
-import { createAgentRuntimeContext } from '../../../src/plugin-sdk.js';
-import type { LoopEvent, Provider } from '../../../src/types.js';
-import {
-  buildTaskArbitrator,
-  isContinuationPhrase,
-  type TaskArbitrationContext,
-} from '../src/taskIdentity.js';
-import { WorkflowState } from '../src/workflowState.js';
-import { runWorkflow } from '../src/runner.js';
-import type { RunContext, StepDef, 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 ACTX: TaskArbitrationContext = {
-  workflowName: 'plan',
-  prevGoal: '写一份产品架构说明 PPT',
-  newGoal: '继续',
-  completedStepIds: ['gathering', 'research'],
-  totalSteps: 5,
-  artifacts: ['PLAN.md'],
-};
-
-// ---------------- 1. 单元：短语快路径 ----------------
-
-describe('taskIdentity::isContinuationPhrase（延续短语快路径）', () => {
-  it('中英文延续短语命中', () => {
-    for (const g of ['继续', '继续吧', '接着做', '继续执行', 'continue', 'resume', 'go on', '继续！']) {
-      expect(isContinuationPhrase(g)).toBe(true);
-    }
-  });
-
-  it('实质性新目标不命中', () => {
-    for (const g of ['写一份产品架构说明 PPT', '帮我重构 runner.ts', '继续深入研究量子计算的产业落地并写一份长篇报告']) {
-      expect(isContinuationPhrase(g)).toBe(false);
-    }
-  });
-});
-
-// ---------------- 2. 单元：复合仲裁器逐级降级 ----------------
-
-describe('taskIdentity::buildTaskArbitrator（仲裁链逐级降级）', () => {
-  it('a. 延续短语 → resume，不调 LLM 也不提问', async () => {
-    let chatCalled = 0;
-    let askCalled = 0;
-    const notes: string[] = [];
-    const arb = buildTaskArbitrator({
-      provider: fakeProvider,
-      chat: async function* () {
-        chatCalled++;
-        yield { type: 'done', stopReason: 'stop' };
-      },
-      executeTool: async () => {
-        askCalled++;
-        return { ok: true, content: '' };
-      },
-      notes,
-    });
-
-    expect(await arb(ACTX)).toBe('resume');
-    expect(chatCalled).toBe(0);
-    expect(askCalled).toBe(0);
-    expect(notes.some((n) => n.includes('延续短语'))).toBe(true);
-  });
-
-  it('b. LLM 判 resume → resume（决断，不提问）', async () => {
-    let askCalled = 0;
-    const arb = buildTaskArbitrator({
-      provider: fakeProvider,
-      chat: async function* () {
-        yield { type: 'text_delta', delta: '{"verdict":"resume","reason":"是延续"}' };
-        yield { type: 'done', stopReason: 'stop' };
-      },
-      executeTool: async () => {
-        askCalled++;
-        return { ok: true, content: '' };
-      },
-    });
-
-    expect(await arb({ ...ACTX, newGoal: '把刚才那个 PPT 做完' })).toBe('resume');
-    expect(askCalled).toBe(0);
-  });
-
-  it('b. LLM 判 new → new（决断）', async () => {
-    const arb = buildTaskArbitrator({
-      provider: fakeProvider,
-      chat: async function* () {
-        yield { type: 'text_delta', delta: '{"verdict":"new","reason":"无关新需求"}' };
-        yield { type: 'done', stopReason: 'stop' };
-      },
-    });
-
-    expect(await arb({ ...ACTX, newGoal: '帮我修一个登录 bug' })).toBe('new');
-  });
-
-  it('c. LLM unsure → AskUserQuestion，按用户选择走（选"继续上次任务"→ resume）', async () => {
-    const arb = buildTaskArbitrator({
-      provider: fakeProvider,
-      chat: async function* () {
-        yield { type: 'text_delta', delta: '{"verdict":"unsure","reason":"说不准"}' };
-        yield { type: 'done', stopReason: 'stop' };
-      },
-      executeTool: async (name: string) => {
-        expect(name).toBe('AskUserQuestion');
-        return { ok: true, content: '用户已回答 AskUserQuestion：\nA1: 继续上次任务' };
-      },
-    });
-
-    expect(await arb({ ...ACTX, newGoal: '模糊输入' })).toBe('resume');
-  });
-
-  it('d. LLM 抛错 + 提问也失败 → 兜底 new（= 旧红线行为）', async () => {
-    const notes: string[] = [];
-    const arb = buildTaskArbitrator({
-      provider: fakeProvider,
-      chat: async function* () {
-        throw new Error('LLM down');
-        // biome-ignore lint/correctness/noUnreachable: stub
-        yield { type: 'done', stopReason: 'stop' };
-      },
-      executeTool: async () => ({ ok: false, error: '提问被取消' }),
-      notes,
-    });
-
-    expect(await arb({ ...ACTX, newGoal: '模糊输入' })).toBe('new');
-    expect(notes.some((n) => n.includes('全新任务'))).toBe(true);
-  });
-});
-
-// ---------------- 3. 状态层：init 接仲裁结果 ----------------
-
-const STEPS: StepDef[] = [
-  { id: 's1', type: 'assert', condition: 'true' },
-  { id: 's2', type: 'assert', condition: 'true' },
-];
-
-describe('workflowState::init × 仲裁（resume 保留现场 / new 清理重开）', () => {
-  let tmp: string;
-
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), 'wf-arb-'));
-  });
-  afterEach(() => {
-    rmSync(tmp, { recursive: true, force: true });
-  });
-
-  it('仲裁判 resume → 保留旧状态与产物、回放 checkpoint、带 prevGoal/supplementaryGoal', async () => {
-    // 旧任务：fresh + 完成一步 + 留产物 + 留补充要求（不 markDone = 未完成）
-    const s1 = new WorkflowState(tmp, 'plan');
-    await s1.init('plan', { goal: '写产品架构 PPT' }, STEPS, 1, ['PLAN.md']);
-    await s1.recordCheckpoint('s1', 'ok', { out: 'v1' }, {});
-    await s1.appendSupplement('用户要求加一章');
-    writeFileSync(join(tmp, 'PLAN.md'), '# 半成品');
-    const oldDir = s1.dir;
-
-    // 新输入「继续」（hash 必然不等）+ 仲裁器判 resume
-    const s2 = new WorkflowState(tmp, 'plan');
-    const r = await s2.init('plan', { goal: '继续' }, STEPS, 1, ['PLAN.md'], async () => 'resume');
-
-    expect(r.mode).toBe('resume');
-    expect(r.completedStepIds).toEqual(['s1']);
-    expect(r.capturedVars?.s1).toEqual({ out: 'v1' });
-    expect(r.prevGoal).toBe('写产品架构 PPT');
-    expect(r.supplementaryGoal).toBe('继续');
-    // 现场未被清理
-    expect(existsSync(join(tmp, 'PLAN.md'))).toBe(true);
-    // 回归：resume 后实例目录必须仍指向旧任务（否则 supplements / checkpoint 全写丢，
-    // 断点续跑静默失效——曾因 finally 误把 this.dir 改回新 hash 目录）
-    expect(s2.dir).toBe(oldDir);
-    expect(await s2.readSupplements()).toEqual(['用户要求加一章']);
-  });
-
-  it('仲裁判 new → 走 new-task 清理重开', async () => {
-    const s1 = new WorkflowState(tmp, 'plan');
-    await s1.init('plan', { goal: '写产品架构 PPT' }, STEPS, 1, ['PLAN.md']);
-    writeFileSync(join(tmp, 'PLAN.md'), '# 旧产物');
-
-    const s2 = new WorkflowState(tmp, 'plan');
-    const r = await s2.init('plan', { goal: '修登录 bug' }, STEPS, 1, ['PLAN.md'], async () => 'new');
-
-    expect(r.mode).toBe('new-task');
-    expect(existsSync(join(tmp, 'PLAN.md'))).toBe(false);
-  });
-
-  it('仲裁器抛错 → 兜底 new-task（不让仲裁 halt 工作流）', async () => {
-    const s1 = new WorkflowState(tmp, 'plan');
-    await s1.init('plan', { goal: '写产品架构 PPT' }, STEPS, 1, []);
-
-    const s2 = new WorkflowState(tmp, 'plan');
-    const r = await s2.init('plan', { goal: '继续' }, STEPS, 1, [], async () => {
-      throw new Error('仲裁崩了');
-    });
-    expect(r.mode).toBe('new-task');
-  });
-
-  it('旧任务已完成（status=done）→ 不仲裁，直接 new-task', async () => {
-    const s1 = new WorkflowState(tmp, 'plan');
-    await s1.init('plan', { goal: '写产品架构 PPT' }, STEPS, 1, []);
-    await s1.markDone(); // 活动目录 done（未归档的边角情形）
-
-    let arbCalled = 0;
-    const s2 = new WorkflowState(tmp, 'plan');
-    const r = await s2.init('plan', { goal: '继续' }, STEPS, 1, [], async () => {
-      arbCalled++;
-      return 'resume';
-    });
-    expect(r.mode).toBe('new-task');
-    expect(arbCalled).toBe(0);
-  });
-
-  it('不同名 workflow 状态按名隔离（E6）→ B 判 fresh、不仲裁、不碰 A 的现场', async () => {
-    // A（other-wf）未完成现场
-    const sA = new WorkflowState(tmp, 'other-wf');
-    await sA.init('other-wf', { goal: '别的事' }, STEPS, 1, []);
-
-    // 跑 B（plan）：A 的状态对 B 不可见 → fresh（不会误判 resume/new-task，也不仲裁）
-    let arbCalled = 0;
-    const sB = new WorkflowState(tmp, 'plan');
-    const r = await sB.init('plan', { goal: '继续' }, STEPS, 1, [], async () => {
-      arbCalled++;
-      return 'resume';
-    });
-    expect(r.mode).toBe('fresh');
-    expect(arbCalled).toBe(0);
-    // A 的现场完好（曾经会被 B 的 new-task 清掉——E6 事故）
-    // 新布局：current.json 在实例子目录里；旧布局兼容时直接在 wfDir 下
-    const aDir = sA.dir;
-    expect(existsSync(join(aDir, 'current.json'))).toBe(true);
-  });
-});
-
-// ---------------- 4. 端到端：runWorkflow「继续」续跑 + goalAnchor 锚旧目标 ----------------
-
-describe('runWorkflow × 仲裁延续（端到端）', () => {
-  let tmp: string;
-  let ctx: RunContext;
-
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), 'wf-arb-e2e-'));
-    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: [],
-      // 显式 sessionId：两次 runWorkflow 同 session，仲裁「继续」才能 resume 旧任务
-      runtimeContext: createAgentRuntimeContext({ surface: 'workflow', profile: 'main', cwd: tmp, sessionId: 'test-session', owner: 'local-owner', interactiveAsk: false }),
-    };
-  });
-  afterEach(() => {
-    delete process.env.MINIMAL_AGENT_CWD;
-    _resetWorkingDir();
-    rmSync(tmp, { recursive: true, force: true });
-  });
-
-  it('输入「继续」→ 短语快路径 resume；goalAnchor 锚旧目标而非「继续」', async () => {
-    const def: WorkflowDef = {
-      name: 'cont-wf',
-      description: 'd',
-      inputs: [{ name: 'goal', type: 'string', required: true }],
-      steps: [
-        // prompt 正文内插 ${inputs.goal}（模拟 plan.yaml 的业务上下文写法）：
-        // 仲裁 resume 时必须渲染旧任务真实目标，不能是「继续」
-        { id: 'g1', llm: '目标：${inputs.goal}，做第一步', capture: { text: 'a' } },
-        { id: 'g2', llm: '目标：${inputs.goal}，做第二步', capture: { text: 'b' } },
-      ],
-    };
-
-    // 第一次：真实目标，g1 成功后 g2 失败（中断现场）
-    let calls = 0;
-    ctx.chat = async function* () {
-      calls++;
-      if (calls === 2) throw new Error('boom'); // g2 失败 → halt，保留现场
-      yield { type: 'text_delta', delta: `out-${calls}` };
-      yield { type: 'done', stopReason: 'stop' };
-    };
-    const ev1 = await collect(runWorkflow(def, { goal: '写产品架构说明文档' }, ctx));
-    expect(ev1.some((e) => e.type === 'workflow_done')).toBe(false);
-
-    // 第二次：输入「继续」→ 仲裁快路径 resume（不该花 LLM 做仲裁）。
-    // 记录每次 chat 收到的 user prompt，验证 goalAnchor 锚的是旧目标。
-    const prompts: string[] = [];
-    ctx.history = [];
-    ctx.chat = async function* (args) {
-      const user = [...args.messages].reverse().find((m) => m.role === 'user');
-      prompts.push(typeof user?.content === 'string' ? user.content : '');
-      yield { type: 'text_delta', delta: 'resumed-out' };
-      yield { type: 'done', stopReason: 'stop' };
-    };
-    const ev2 = await collect(runWorkflow(def, { goal: '继续' }, ctx));
-
-    expect(ev2.some((e) => e.type === 'workflow_done')).toBe(true);
-    // 仲裁可见化：延续短语 warning
-    expect(
-      ev2.some((e) => e.type === 'warning' && e.message.includes('延续短语')),
-    ).toBe(true);
-    // goalAnchor 锚旧目标 + 补充指令，而不是把「继续」当目标
-    expect(prompts.length).toBeGreaterThan(0);
-    for (const p of prompts) {
-      expect(p).toContain('写产品架构说明文档');
-      expect(p).not.toContain('用户原始目标：继续');
-      // prompt 正文的 ${inputs.goal} 内插也必须是旧目标（VarStack inputs 已替换）
-      expect(p).toContain('目标：写产品架构说明文档');
-      expect(p).not.toContain('目标：继续');
-    }
-  });
-});