minimal-agent 0.10.0 → 0.12.0

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

@@ -0,0 +1,114 @@
+/**
+ * ============================================================
+ *  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

@@ -0,0 +1,338 @@
+/**
+ * ============================================================
+ *  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('目标：继续');
+    }
+  });
+});

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

@@ -0,0 +1,237 @@
+/**
+ * ============================================================
+ *  test/taskIdentity.test.ts —— 任务身份判定单元测试
+ * ------------------------------------------------------------
+ *  覆盖 taskIdentity.ts 的所有核心功能：
+ *    - computeTaskId() hash 计算
+ *    - 时间窗口判定（30分钟内视为同任务）
+ *    - 任务身份匹配逻辑（hash_match / time_window / expired / different_workflow）
+ *    - normalizeGoal() 归一化规则
+ *    - extractGoal() 提取策略
+ *
+ *  设计原则：
+ *    - 不依赖文件系统（computeTaskId 在无 workingDir 时返回 no_previous）
+ *    - 需要文件系统时用 tmpdir + 手写 current.json
+ *    - 纯函数逻辑用大量边界用例覆盖
+ * ============================================================
+ */
+
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { computeTaskId } from '../src/taskIdentity.js';
+
+describe('taskIdentity::normalizeGoal (隐式测试 via computeTaskId)', () => {
+  it('相同内容产生相同 hash（确定性）', () => {
+    const r1 = computeTaskId('test-wf', { goal: 'hello world' });
+    const r2 = computeTaskId('test-wf', { goal: 'hello world' });
+    expect(r1.hash).toBe(r2.hash);
+    expect(r1.hash.length).toBe(16);
+  });
+
+  it('不同内容产生不同 hash（碰撞敏感度）', () => {
+    const r1 = computeTaskId('test-wf', { goal: '目标A' });
+    const r2 = computeTaskId('test-wf', { goal: '目标B' });
+    expect(r1.hash).not.toBe(r2.hash);
+  });
+
+  it('大小写不敏感（归一化转小写）', () => {
+    const r1 = computeTaskId('test-wf', { goal: 'Hello World' });
+    const r2 = computeTaskId('test-wf', { goal: 'hello world' });
+    expect(r1.hash).toBe(r2.hash);
+  });
+
+  it('标点符号被去除', () => {
+    const r1 = computeTaskId('test-wf', { goal: 'Hello, World!' });
+    const r2 = computeTaskId('test-wf', { goal: 'hello world' });
+    expect(r1.hash).toBe(r2.hash);
+  });
+
+  it('多余空格被压缩', () => {
+    const r1 = computeTaskId('test-wf', { goal: 'hello   world' });
+    const r2 = computeTaskId('test-wf', { goal: 'hello world' });
+    expect(r1.hash).toBe(r2.hash);
+  });
+
+  it('中文保留正常', () => {
+    const r = computeTaskId('test-wf', { goal: '实现用户认证模块' });
+    expect(r.hash.length).toBe(16);
+    // 中文不应被去除
+    expect(r.hash).toMatch(/^[0-9a-f]{16}$/);
+  });
+
+  it('超长输入被截断到 200 字符', () => {
+    const longGoal = 'a'.repeat(300);
+    const r1 = computeTaskId('test-wf', { goal: longGoal });
+    const r2 = computeTaskId('test-wf', { goal: 'a'.repeat(200) });
+    expect(r1.hash).toBe(r2.hash);
+  });
+
+  it('首尾空格被 trim', () => {
+    const r1 = computeTaskId('test-wf', { goal: '  hello world  ' });
+    const r2 = computeTaskId('test-wf', { goal: 'hello world' });
+    expect(r1.hash).toBe(r2.hash);
+  });
+});
+
+describe('taskIdentity::extractGoal 策略', () => {
+  it('优先级1：直接使用 inputs.goal', () => {
+    const r1 = computeTaskId('wf', { goal: '我的目标', other: '忽略这个' });
+    const r2 = computeTaskId('wf', { goal: '我的目标', other: '不同的值' });
+    expect(r1.hash).toBe(r2.hash); // 只看 goal
+  });
+
+  it('优先级2：无 goal 时取第一个 length > 2 的 string 值', () => {
+    const r1 = computeTaskId('wf', { short: 'ab', description: '这是一个较长的描述' });
+    // 应该取 description（length > 2），而不是 short
+    const r2 = computeTaskId('wf', { description: '这是一个较长的描述' });
+    expect(r1.hash).toBe(r2.hash);
+  });
+
+  it('优先级3：所有 string 都太短时 JSON 序列化整个 inputs', () => {
+    const r1 = computeTaskId('wf', { a: 'x', b: 'y' });
+    const r2 = computeTaskId('wf', { a: 'x', b: 'y' });
+    expect(r1.hash).toBe(r2.hash); // 确定性
+    expect(r1.hash.length).toBe(16);
+  });
+
+  it('空 inputs 也能处理', () => {
+    const r = computeTaskId('wf', {});
+    expect(r.hash.length).toBe(16);
+  });
+
+  it('非 string 值被跳过（number/boolean/null）', () => {
+    const r1 = computeTaskId('wf', { count: 42, flag: true });
+    const r2 = computeTaskId('wf', {});
+    // 没有可用的 string → 都走 JSON.stringify
+    // 但序列化结果不同，所以 hash 不同是正常的
+    expect(r1.hash.length).toBe(16);
+    expect(r2.hash.length).toBe(16);
+  });
+});
+
+describe('taskIdentity::无 workingDir 基础行为', () => {
+  it('无 workingDir → isSameTask=false, reason=no_previous', () => {
+    const r = computeTaskId('test-wf', { goal: 'hello' });
+    expect(r.isSameTask).toBe(false);
+    expect(r.reason).toBe('no_previous');
+  });
+
+  it('不同 workflow 名产生不同 hash', () => {
+    const r1 = computeTaskId('wf-a', { goal: 'same goal' });
+    const r2 = computeTaskId('wf-b', { goal: 'same goal' });
+    expect(r1.hash).not.toBe(r2.hash); // workflow 名参与 hash
+  });
+});
+
+describe('taskIdentity::文件系统交互（时间窗口 + hash 匹配）', () => {
+  let tmp: string;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), 'task-id-'));
+  });
+
+  afterEach(() => {
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  function writeCurrentState(data: {
+    taskId?: string;
+    name?: string;
+    startedAt?: string;
+    status?: string;
+  }): void {
+    // E6 后状态目录按 workflow 名隔离：computeTaskId('test-wf', …) 读 test-wf/ 子目录
+    const stateDir = join(tmp, '.minimal-agent-workflow', 'test-wf');
+    mkdirSync(stateDir, { recursive: true });
+    writeFileSync(
+      join(stateDir, 'current.json'),
+      JSON.stringify(data, null, 2),
+      'utf8',
+    );
+  }
+
+  it('无 current.json → no_previous', () => {
+    const r = computeTaskId('test-wf', { goal: 'hello' }, tmp);
+    expect(r.isSameTask).toBe(false);
+    expect(r.reason).toBe('no_previous');
+  });
+
+  it('不同 workflow 名 → different_workflow', () => {
+    writeCurrentState({
+      name: 'other-wf',
+      taskId: 'abc123',
+      startedAt: new Date().toISOString(),
+    });
+    const r = computeTaskId('test-wf', { goal: 'hello' }, tmp);
+    expect(r.isSameTask).toBe(false);
+    expect(r.reason).toBe('different_workflow');
+  });
+
+  it('时间窗口内但 goal 不同 → 仍判不同任务（hash 权威，recency 不覆盖）', () => {
+    // 刚刚启动的任务，但这次换了完全不同的 goal
+    writeCurrentState({
+      name: 'test-wf',
+      taskId: 'old-hash',
+      startedAt: new Date().toISOString(),
+    });
+    const r = computeTaskId('test-wf', { goal: '完全不同的新目标' }, tmp);
+    // 30 分钟内换不同 goal 必须当成全新任务（需求 3.2「不相关新任务自动清理重开」），
+    // 而非旧版「时间窗口覆盖 hash」错误 resume 旧任务把旧变量混进新目标。
+    expect(r.isSameTask).toBe(false);
+    expect(r.reason).toBe('hash_diff');
+    expect(r.hash).not.toBe('old-hash');
+  });
+
+  it('时间窗口过期 + hash 匹配 → hash_match', () => {
+    // 31 分钟前启动的任务（超出 30 分钟窗口）
+    const pastDate = new Date(Date.now() - 31 * 60 * 1000);
+    const expectedHash = computeTaskId('test-wf', { goal: 'same goal' }).hash;
+
+    writeCurrentState({
+      name: 'test-wf',
+      taskId: expectedHash,
+      startedAt: pastDate.toISOString(),
+    });
+    const r = computeTaskId('test-wf', { goal: 'same goal' }, tmp);
+    expect(r.isSameTask).toBe(true);
+    expect(r.reason).toBe('hash_match');
+  });
+
+  it('hash 不匹配 → 不同任务（hash_diff，与时间无关）', () => {
+    const pastDate = new Date(Date.now() - 31 * 60 * 1000);
+    writeCurrentState({
+      name: 'test-wf',
+      taskId: 'some-old-hash',
+      startedAt: pastDate.toISOString(),
+    });
+    const r = computeTaskId('test-wf', { goal: 'completely new target' }, tmp);
+    expect(r.isSameTask).toBe(false);
+    expect(r.reason).toBe('hash_diff');
+  });
+
+  it('损坏的 current.json → 容错返回 no_previous', () => {
+    const stateDir = join(tmp, '.minimal-agent-workflow', 'test-wf');
+    mkdirSync(stateDir, { recursive: true });
+    writeFileSync(join(stateDir, 'current.json'), '{invalid json', 'utf8');
+
+    const r = computeTaskId('test-wf', { goal: 'hello' }, tmp);
+    expect(r.isSameTask).toBe(false);
+    expect(r.reason).toBe('no_previous');
+  });
+
+  it('current.json 缺少 startedAt 字段 → 降级为 hash 比较', () => {
+    const expectedHash = computeTaskId('test-wf', { goal: 'target' }).hash;
+    writeCurrentState({
+      name: 'test-wf',
+      taskId: expectedHash,
+      // 没有 startedAt
+    });
+    const r = computeTaskId('test-wf', { goal: 'target' }, tmp);
+    // 无 startedAt 时时间窗口检查不通过，走 hash 匹配
+    expect(r.isSameTask).toBe(true);
+    expect(r.reason).toBe('hash_match');
+  });
+});