minimal-agent 0.12.0 → 0.13.0

package/plugins/workflow-runner/test/research.load.test.ts

@@ -0,0 +1,328 @@
+/**
+ * test/research.load.test.ts
+ * ------------------------------------------------------------
+ * 锁定 workflows/research.yaml（技术研究工作流：定义问题→测绘地图→方案对比→
+ * 深度调研→动手验证→综合升华→补洞→报告拼装）的「可解析 + 关键骨架 + 所有表达式合法」。
+ */
+
+import { describe, expect, it } from 'bun:test';
+import { join } from 'node:path';
+
+import { evalExpr, interpolate } from '../src/expressions.js';
+import { parseWorkflowFile } from '../src/loader.js';
+import { VarStack } from '../src/types.js';
+import type { StepDef } from '../src/types.js';
+
+const wfPath = join(
+  import.meta.dir.replace(/[/\\]test$/, ''),
+  '..',
+  '..',
+  'workflows',
+  'research.yaml',
+);
+
+function allStrings(def: unknown): string[] {
+  const out: string[] = [];
+  const walk = (v: unknown): void => {
+    if (typeof v === 'string') out.push(v);
+    else if (Array.isArray(v)) for (const x of v) walk(x);
+    else if (v && typeof v === 'object')
+      for (const x of Object.values(v as Record<string, unknown>)) walk(x);
+  };
+  walk(def);
+  return out;
+}
+
+function allStepsRec(steps: StepDef[]): StepDef[] {
+  const out: StepDef[] = [];
+  const go = (s: StepDef) => {
+    out.push(s);
+    if (Array.isArray(s.do)) s.do.forEach(go);
+    if (Array.isArray(s.then)) s.then.forEach(go);
+    if (Array.isArray(s.else)) s.else.forEach(go);
+  };
+  steps.forEach(go);
+  return out;
+}
+
+describe('workflows/research.yaml（技术研究工作流）', () => {
+  it('解析通过、name=research、inputs 正确', async () => {
+    const def = await parseWorkflowFile(wfPath);
+    expect(def.name).toBe('research');
+    expect(typeof def.description).toBe('string');
+    expect(def.description.length).toBeGreaterThan(10);
+
+    const inputs = def.inputs ?? [];
+    const names = inputs.map((i) => i.name);
+    expect(names).toEqual(['topic', 'depth', 'max_iterations']);
+    expect(inputs[0].greedy).toBe(true);
+    expect(inputs[0].required).toBe(true);
+    expect(inputs[1].default).toBe('standard');
+    expect(inputs[2].default).toBe(2);
+  });
+
+  it('骨架齐全：init -> s0(goal) -> s0_pause -> s1(map) -> [early-exit 判定] -> s2(options) -> s3(per-branch 深挖 loop) -> s4(verify) -> s5(synthesis) -> s5b(补洞 loop) -> s6(拼装) -> done', async () => {
+    const def = await parseWorkflowFile(wfPath);
+    const ids = def.steps.map((s) => s.id);
+    const expectOrder = [
+      'init',
+      's0_goal',
+      's0_pause',
+      's1_map',
+      's1_load_exit',
+      's1_exit_report',
+      's2_options',
+      's2_load_branches',
+      's2_assert_branches',
+      's3_deep_dive',
+      's4_verify',
+      's5_synthesis',
+      's5b_loop',
+      's5c_check_synthesis',
+      's5c_assert_synthesis',
+      's6_build_report',
+      's6_package',
+      's6_assert_report',
+      'done',
+    ];
+    for (const id of expectOrder) expect(ids).toContain(id);
+    // 顺序
+    for (let i = 1; i < expectOrder.length; i++) {
+      expect(ids.indexOf(expectOrder[i - 1])).toBeLessThan(ids.indexOf(expectOrder[i]));
+    }
+  });
+
+  it('early-exit 双路径：s1_exit_report 在 _early_exit==true 时补齐全套文件；主阶段以 when=_early_exit != true 守卫跳过', async () => {
+    const def = await parseWorkflowFile(wfPath);
+    const byId = new Map(def.steps.map((s) => [s.id, s]));
+
+    const exitReport = byId.get('s1_exit_report');
+    expect(exitReport?.when).toBe('_early_exit == true');
+    // 简化路径必须补齐 s6 拼装所需的全部文件（done_when 锁定）
+    const dw = String(exitReport?.done_when);
+    for (const f of ['03-options.md', 'branches.json', '05-verification.md', '06-synthesis.md', '07-learning-debt.md', 'gaps.json']) {
+      expect(dw).toContain(f);
+    }
+
+    // 主阶段守卫：s2 / s4 / s5 / s5b 在 early-exit 时跳过
+    for (const id of ['s2_options', 's4_verify', 's5_synthesis', 's5b_loop']) {
+      expect(byId.get(id)?.when).toBe('_early_exit != true');
+    }
+    // assert 只在正常路径执行（early 路径 branches=[] 天然放行，无需弱化条件）
+    expect(byId.get('s2_assert_branches')?.when).toBe('_early_exit != true');
+    expect(String(byId.get('s2_assert_branches')?.condition)).toBe('length(branches) > 0');
+    // s1_map 的完成闸门包含 early-exit.json
+    expect(String(byId.get('s1_map')?.done_when)).toContain('early-exit.json');
+  });
+
+  it('阶段0 零搜索（设计文档红线）：allowed_tools 不含 WebSearch/WebFetch', async () => {
+    const def = await parseWorkflowFile(wfPath);
+    const s0 = def.steps.find((s) => s.id === 's0_goal');
+    const tools = (s0?.allowed_tools ?? []) as string[];
+    expect(tools).not.toContain('WebSearch');
+    expect(tools).not.toContain('WebFetch');
+    expect(tools).toEqual(['Read', 'Write']);
+  });
+
+  it('s5c 形式校验：确定性检查综合报告含必备章节（不依赖 agent 自觉）', async () => {
+    const def = await parseWorkflowFile(wfPath);
+    const check = def.steps.find((s) => s.id === 's5c_check_synthesis');
+    expect(check?.tool).toBe('Bash');
+    expect(String((check?.args as any)?.command)).toContain('grep');
+
+    const gate = def.steps.find((s) => s.id === 's5c_assert_synthesis');
+    expect(gate?.type).toBe('assert');
+    expect(String(gate?.condition)).toContain('核心结论');
+    expect(String(gate?.condition)).toContain('推荐方案');
+  });
+
+  it('s3_deep_dive：for-each loop over branches、fresh_context、done_when 用 + 拼路径', async () => {
+    const def = await parseWorkflowFile(wfPath);
+    const loop = def.steps.find((s) => s.id === 's3_deep_dive');
+    expect(loop?.type).toBe('loop');
+    expect(String(loop?.over)).toContain('branches');
+    expect(loop?.as).toBe('branch');
+    expect(loop?.fresh_context).toBe(true);
+
+    const dive = ((loop?.do ?? []) as StepDef[]).find((s) => s.id === 's3_dive_one');
+    expect(dive?.type).toBeUndefined(); // 不是控制流，是 agent 步
+    expect(typeof dive?.agent).toBe('string');
+    // allowed_tools 必须限制为只读调研工具
+    expect(dive?.allowed_tools).toEqual(
+      expect.arrayContaining(['WebSearch', 'WebFetch', 'Read', 'Write']),
+    );
+    // done_when 用 + 拼接路径
+    expect(String(dive?.done_when)).toContain('branch.safe_name');
+    expect(String(dive?.done_when)).toContain('+');
+  });
+
+  it('s5b_loop：while 模式（无 over）+ max_iterations=${inputs.max_iterations} + branch condition 判定缺口', async () => {
+    const def = await parseWorkflowFile(wfPath);
+    const loop = def.steps.find((s) => s.id === 's5b_loop');
+    expect(loop?.type).toBe('loop');
+    expect(loop?.over).toBeUndefined(); // while 模式
+    expect(String(loop?.max_iterations)).toContain('inputs.max_iterations');
+
+    const inner = (loop?.do ?? []) as StepDef[];
+    const brk = inner.find((s) => s.id === 's5b_break_if_empty');
+    expect(brk?.type).toBe('branch');
+    expect(String(brk?.condition)).toContain('length(_gaps)');
+    // then 里有 break
+    expect(((brk?.then ?? []) as StepDef[]).some((s) => s.type === 'break')).toBe(true);
+  });
+
+  it('s0_pause：真 HITL 闸门（free_text=approve，用户输入作为补充要求贯穿）', async () => {
+    const def = await parseWorkflowFile(wfPath);
+    const pause = def.steps.find((s) => s.id === 's0_pause');
+    expect(pause?.type).toBe('pause');
+    expect(pause?.free_text).toBe('approve');
+    expect(typeof pause?.prompt).toBe('string');
+  });
+
+  it('s6_build_report：确定性 Bash 拼装 out/research/${session}/deliverable/report.md（不烧 LLM），sec 降级标题，s6_package 精选脚本', async () => {
+    const def = await parseWorkflowFile(wfPath);
+    const build = def.steps.find((s) => s.id === 's6_build_report');
+    expect(build?.tool).toBe('Bash');
+    const cmd = String((build?.args as any)?.command);
+    // Phase 3：产物路径按 session 隔离（${session} 占位符由引擎展开）
+    expect(cmd).toContain('out/research/${session}/deliverable/report.md');
+    expect(cmd).toContain('sec out/research/${session}/01-goal.md');
+    expect(cmd).toContain('04-deep-dive');
+    expect(cmd).toContain("sed -E 's/^(#+) /\\1## /'");
+    expect((build?.artifacts ?? [])?.length).toBeGreaterThan(0);
+
+    const pkg = def.steps.find((s) => s.id === 's6_package');
+    expect(typeof pkg?.agent).toBe('string');
+    expect(String(pkg?.done_when)).toContain('deliverable/scripts/README.md');
+
+    const gate = def.steps.find((s) => s.id === 's6_assert_report');
+    expect(String(gate?.condition)).toContain('out/research/${session}/deliverable/report.md');
+  });
+
+  it('s6 Bash 转义与注入防线：\\$ 经引擎插值还原为 $（Bash 变量可展开）；自由文本 topic 不进命令体', async () => {
+    const def = await parseWorkflowFile(wfPath);
+    const build = def.steps.find((s) => s.id === 's6_build_report');
+    const rawCmd = String((build?.args as any)?.command);
+
+    // 注入防线：自由文本 inputs.topic 不得出现在任何 Bash 命令体里（enum 白名单的 depth 可以）
+    expect(rawCmd).not.toContain('${inputs.topic}');
+    const initCmd = String(
+      ((def.steps.find((s) => s.id === 'init')?.args as any) ?? {}).command,
+    );
+    expect(initCmd).not.toContain('${inputs.topic}');
+
+    // 转义还原：引擎 interpolate 把 \$ 还原为 $ 后再交给 Bash --
+    // \$f/\$OUT 必须被还原（否则 Bash 拿到字面 $f 文件名，deep-dive 拼装会静默空白）
+    const vars = new VarStack();
+    vars.setGlobal('inputs', { topic: 'T', depth: 'standard', max_iterations: 2 });
+    const out = interpolate(rawCmd, vars);
+    expect(out).not.toContain('\\$');
+    expect(out).toContain('$OUT');
+    expect(out).toContain('$f');
+  });
+
+  it('所有 tool: Bash 步骤的命令体都不触发 permanentDeleteGuard（包括注释里的示例代码）', async () => {
+    const def = await parseWorkflowFile(wfPath);
+    const bashSteps = def.steps.filter(
+      (s) => (s as any).tool === 'Bash',
+    );
+    expect(bashSteps.length).toBeGreaterThan(0);
+
+    // 逐行匹配 permanentDeleteGuard 的 BASH_DELETE 正则：
+    //   /(?:^|[;&|\n])\s*(?:sudo\s+)?(?:rm|unlink|rmdir)\b/i
+    //   /(?:^|[;&|\n])\s*find\b[^\n;&|]*\s-delete\b/i
+    const delPatterns = [
+      /(?:^|[;&|\n])\s*(?:sudo\s+)?(?:rm|unlink|rmdir)\b/i,
+      /(?:^|[;&|\n])\s*find\b[^\n;&|]*\s-delete\b/i,
+    ];
+    for (const step of bashSteps) {
+      const cmd = String(((step as any).args as any).command ?? '');
+      for (const pat of delPatterns) {
+        if (pat.test(cmd)) {
+          throw new Error(
+            `步骤 ${step.id} 的 Bash 命令体命中了 permanentDeleteGuard 正则 ${pat.toString()}`,
+          );
+        }
+      }
+    }
+  });
+
+  it('所有 ${} 模板插值和裸表达式都能被引擎求值（不抛错）', async () => {
+    const def = await parseWorkflowFile(wfPath);
+    const vars = new VarStack();
+    vars.setGlobal('inputs', {
+      topic: 'Rust 异步运行时',
+      depth: 'standard',
+      max_iterations: 2,
+    });
+    vars.setGlobal('branches', [
+      { name: 'Tokio', safe_name: 'tokio', description: '主流' },
+      { name: 'async-std', safe_name: 'async-std', description: '另一个' },
+    ]);
+    vars.setGlobal('_gaps', []);
+    vars.setGlobal('_init_out', 'init_ok');
+    vars.setGlobal('session', 'default');
+    vars.setGlobal('_report_out', 'ok:out/research/${session}/deliverable/report.md');
+    vars.setIteration('branch', { name: 'Tokio', safe_name: 'tokio', description: '主流' });
+    vars.setIteration('branch_idx', 0);
+    vars.setIteration('_iter', 0);
+    vars.setIteration('_iter_idx', 0);
+
+    // 模板插值
+    for (const s of allStrings(def)) {
+      if (!s.includes('${')) continue;
+      expect(() => interpolate(s, vars)).not.toThrow(
+        `字符串插值失败: ${s.slice(0, 200)}`,
+      );
+    }
+
+    // 裸表达式：when / condition / over / done_when / set 值 / max_iterations
+    const naked: Array<[string, string]> = [];
+    for (const s of allStepsRec(def.steps)) {
+      if (s.when) naked.push([`${s.id}.when`, s.when]);
+      if (s.condition) naked.push([`${s.id}.condition`, s.condition]);
+      if (typeof s.over === 'string') naked.push([`${s.id}.over`, s.over]);
+      if (s.done_when) naked.push([`${s.id}.done_when`, s.done_when]);
+      if (typeof s.max_iterations === 'string')
+        naked.push([`${s.id}.max_iterations`, s.max_iterations]);
+      for (const [k, v] of Object.entries(s.set ?? {})) {
+        if (typeof v === 'string' && v.startsWith('${') && v.endsWith('}')) {
+          naked.push([`${s.id}.set.${k}`, v.slice(2, -1)]);
+        }
+      }
+    }
+    for (const [loc, expr] of naked) {
+      expect(() => evalExpr(expr, vars)).not.toThrow(
+        `表达式失败 [${loc}]: ${expr}`,
+      );
+    }
+  });
+
+  it('补洞收敛可见化：s5b_final_gaps 恒执行（无 when），done 按剩余缺口数分流提示', async () => {
+    const def = await parseWorkflowFile(wfPath);
+    const steps = allStepsRec(def.steps);
+
+    // s5b_final_gaps 无 when 守卫：early-exit 路径也执行（gaps.json=[] 由 s1_exit_report 补齐），
+    // 保证 done 引用的 _remaining_gaps 恒有定义
+    const fg = steps.find((s) => s.id === 's5b_final_gaps');
+    expect(fg).toBeDefined();
+    expect(fg?.when).toBeUndefined();
+    expect(String(fg?.set?._remaining_gaps)).toContain("readJson('out/research/${session}/gaps.json')");
+
+    // done 消息按 _remaining_gaps 分流：>0 警告剩余缺口，=0 报告收敛
+    const done = steps.find((s) => s.id === 'done');
+    const msg = String(done?.message);
+    expect(msg).toContain('_remaining_gaps > 0');
+    expect(msg).toContain('缺口未补全');
+    expect(msg).toContain('已全部收敛');
+
+    // 三元插值在两种取值下都能求值（模拟 done 执行）
+    const vars = new VarStack();
+    vars.setGlobal('inputs', { topic: 'T', depth: 'light', max_iterations: 1 });
+    const ternary = '_remaining_gaps > 0 ? \'⚠️ 仍有 \' + _remaining_gaps + \' 条缺口\' : \'✅ 收敛\'';
+    vars.setGlobal('_remaining_gaps', 3);
+    expect(evalExpr(ternary, vars)).toContain('3 条缺口');
+    vars.setGlobal('_remaining_gaps', 0);
+    expect(evalExpr(ternary, vars)).toContain('收敛');
+  });
+});

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

@@ -28,6 +28,7 @@ import {
   existsSync,
   mkdirSync,
   mkdtempSync,
+  readdirSync,
   readFileSync,
   rmSync,
   writeFileSync,
@@ -36,6 +37,7 @@ 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';
@@ -43,6 +45,43 @@ import type { RunContext, WorkflowDef, WorkflowEvent } from '../src/types.js';
 
 type WfOrLoop = WorkflowEvent | LoopEvent;
 
+const DEFAULT_SESSION = 'test-session';
+
+function findInstanceDir(base: string, wfName: string, suffix = ''): string | null {
+  const wfDir = join(base, '.minimal-agent-workflow', wfName);
+  if (!existsSync(wfDir)) {
+    const legacyDir = suffix
+      ? join(base, '.minimal-agent-workflow', wfName + suffix)
+      : wfDir;
+    if (existsSync(legacyDir)) return legacyDir;
+    return null;
+  }
+
+  // Phase 3：session 化——实例目录名 = sessionId（默认 'default'）
+  const sessionDir = suffix
+    ? join(wfDir, DEFAULT_SESSION + suffix)
+    : join(wfDir, DEFAULT_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;
+}
+
 const fakeProvider: Provider = {
   name: 'test',
   baseURL: '',
@@ -72,7 +111,13 @@ describe('runner::pre-flight fresh 模式', () => {
       initWorkingDir: () => tmp,
       _resetWorkingDir: () => {},
     }));
-    ctx = { provider: fakeProvider, history: [], cwd: tmp, tools: [] };
+    ctx = {
+      provider: fakeProvider,
+      history: [],
+      cwd: tmp,
+      tools: [],
+      runtimeContext: createAgentRuntimeContext({ surface: 'workflow', profile: 'main', cwd: tmp, sessionId: DEFAULT_SESSION, owner: 'local-owner', interactiveAsk: false }),
+    };
   });
 
   afterEach(() => {
@@ -125,7 +170,13 @@ describe('runner::resume 与断点续执行', () => {
       initWorkingDir: () => tmp,
       _resetWorkingDir: () => {},
     }));
-    ctx = { provider: fakeProvider, history: [], cwd: tmp, tools: ALL_TOOLS };
+    ctx = {
+      provider: fakeProvider,
+      history: [],
+      cwd: tmp,
+      tools: ALL_TOOLS,
+      runtimeContext: createAgentRuntimeContext({ surface: 'workflow', profile: 'main', cwd: tmp, sessionId: DEFAULT_SESSION, owner: 'local-owner', interactiveAsk: false }),
+    };
   });
 
   afterEach(() => {
@@ -254,7 +305,13 @@ describe('runner::self_heal retry 机制', () => {
       initWorkingDir: () => tmp,
       _resetWorkingDir: () => {},
     }));
-    ctx = { provider: fakeProvider, history: [], cwd: tmp, tools: [] };
+    ctx = {
+      provider: fakeProvider,
+      history: [],
+      cwd: tmp,
+      tools: [],
+      runtimeContext: createAgentRuntimeContext({ surface: 'workflow', profile: 'main', cwd: tmp, sessionId: DEFAULT_SESSION, owner: 'local-owner', interactiveAsk: false }),
+    };
   });
 
   afterEach(() => {
@@ -350,9 +407,9 @@ describe('runner::self_heal retry 机制', () => {
 
     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);
+    // 成功后应 archive（活动实例目录改名 .done；workflow 级父目录保留）
+    expect(hasInstance(tmp, 'archive-test')).toBe(false);
+    expect(hasInstance(tmp, 'archive-test', '.done')).toBe(true);
   });
 
   it('失败路径 → 保留状态目录供排查', async () => {
@@ -367,12 +424,12 @@ describe('runner::self_heal retry 机制', () => {
 
     await collect(runWorkflow(def, {}, ctx));
 
-    // 失败时应保留状态目录（E6 后按名隔离）
-    expect(existsSync(join(tmp, '.minimal-agent-workflow', 'keep-state'))).toBe(true);
+    // 失败时应保留状态目录（workflow 级父目录 + 实例目录）
+    expect(hasInstance(tmp, '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');
+    const instDir = findInstanceDir(tmp, 'keep-state');
+    if (instDir) {
+      const progress = readFileSync(join(instDir, 'progress.md'), 'utf8');
       expect(progress).toContain('fail');
     }
   });

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

@@ -12,11 +12,12 @@
  */
 
 import { afterEach, beforeEach, describe, expect, it, mock } from 'bun:test';
-import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
+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';
@@ -41,6 +42,45 @@ async function collect(
 }
 
 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;
@@ -55,7 +95,14 @@ describe('workflow state-dir 生命周期', () => {
       initWorkingDir: () => tmp,
       _resetWorkingDir: () => {},
     }));
-    ctx = { provider: fakeProvider, history: [], cwd: tmp, tools: ALL_TOOLS };
+    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(() => {
@@ -73,8 +120,8 @@ describe('workflow state-dir 生命周期', () => {
     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);
+    expect(hasInstance(tmp, 'ok')).toBe(false);
+    expect(hasInstance(tmp, 'ok', '.done')).toBe(true);
   });
 
   it('halt → 保留状态目录 + progress.md 含失败那步', async () => {
@@ -91,9 +138,10 @@ describe('workflow state-dir 生命周期', () => {
     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');
+    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');
@@ -106,7 +154,7 @@ describe('workflow state-dir 生命周期', () => {
       steps: [{ id: 'f', type: 'assert', condition: 'false', onFail: 'x' }],
     };
     await collect(runWorkflow(failDef, {}, ctx));
-    expect(existsSync(join(tmp, STATE_DIR, 'rerun'))).toBe(true); // 失败留下了
+    expect(hasInstance(tmp, 'rerun')).toBe(true); // 失败留下了
 
     // 第二次成功跑（同名同 inputs = 同任务 resume）：成功后归档 → 活动目录干净
     const okDef: WorkflowDef = {
@@ -115,8 +163,8 @@ describe('workflow state-dir 生命周期', () => {
       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);
+    expect(hasInstance(tmp, 'rerun')).toBe(false); // 不堆积
+    expect(hasInstance(tmp, 'rerun', '.done')).toBe(true);
   });
 
   it('E6：A 工作流失败现场不被不同名工作流 B 的运行破坏（按名隔离）', async () => {
@@ -131,7 +179,7 @@ describe('workflow state-dir 生命周期', () => {
       ],
     };
     await collect(runWorkflow(aDef, {}, ctx));
-    expect(existsSync(join(tmp, STATE_DIR, 'wf-a'))).toBe(true);
+    expect(hasInstance(tmp, 'wf-a')).toBe(true);
     expect(existsSync(join(tmp, 'A-PLAN.md'))).toBe(true);
 
     // 跑不同名工作流 B（曾经会清掉 A 的状态目录和产物——E6 事故）
@@ -144,7 +192,7 @@ describe('workflow state-dir 生命周期', () => {
     expect(evB.some((e) => e.type === 'workflow_done')).toBe(true);
 
     // A 的现场与产物完好，resume 能力保留
-    expect(existsSync(join(tmp, STATE_DIR, 'wf-a'))).toBe(true);
+    expect(hasInstance(tmp, 'wf-a')).toBe(true);
     expect(existsSync(join(tmp, 'A-PLAN.md'))).toBe(true);
   });
 });

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

@@ -24,6 +24,7 @@ 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,
@@ -185,11 +186,13 @@ describe('workflowState::init × 仲裁（resume 保留现场 / new 清理重开
   });
 
   it('仲裁判 resume → 保留旧状态与产物、回放 checkpoint、带 prevGoal/supplementaryGoal', async () => {
-    // 旧任务：fresh + 完成一步 + 留产物（不 markDone = 未完成）
+    // 旧任务：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');
@@ -202,6 +205,10 @@ describe('workflowState::init × 仲裁（resume 保留现场 / new 清理重开
     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 () => {
@@ -257,7 +264,9 @@ describe('workflowState::init × 仲裁（resume 保留现场 / new 清理重开
     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);
+    // 新布局：current.json 在实例子目录里；旧布局兼容时直接在 wfDir 下
+    const aDir = sA.dir;
+    expect(existsSync(join(aDir, 'current.json'))).toBe(true);
   });
 });
 
@@ -276,7 +285,14 @@ describe('runWorkflow × 仲裁延续（端到端）', () => {
       initWorkingDir: () => tmp,
       _resetWorkingDir: () => {},
     }));
-    ctx = { provider: fakeProvider, history: [], cwd: tmp, tools: [] };
+    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;