minimal-agent 0.12.0 → 0.14.0

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,338 +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 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' }, {});
-    writeFileSync(join(tmp, 'PLAN.md'), '# 半成品');
-
-    // 新输入「继续」（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);
-  });
-
-  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 事故）
-    expect(existsSync(join(tmp, '.minimal-agent-workflow', 'other-wf', '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: [] };
-  });
-  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('目标：继续');
-    }
-  });
-});