minimal-agent 0.11.0 → 0.13.0

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

@@ -144,4 +144,24 @@ describe('CLI 端到端 /workflow（拉子进程跑 main.tsx）', () => {
     },
     SPAWN_TIMEOUT,
   );
+
+  // B7：用户 shell 习惯写 --input brief=A B C（没加引号），shell 拆成 --input brief=A + B + C
+  // 三个 token；引擎识别为首参已由 --input 提供、但仍存在散落位置参数，按贪婪语义自动拼回，
+  // 不丢 B、C（之前 B/C 被当占位参数映射给后续非贪婪 input，或直接静默丢弃）。
+  it(
+    'B7：贪婪首参用 --input 提供但没加引号被拆 → 位置参数自动拼回首参',
+    async () => {
+      // 注意：命令字符串本身在这里是单条 input，但引擎 tokenize 后是:
+      //   [/workflow, greedy-e2e, --input, brief=做, 一个, 小玩具]
+      // 即 greedy-e2e 之后的内容中，--input brief=做 是首参赋值，「一个」「小玩具」
+      // 是被 shell-like 拆分出来的位置参数，B7 修复后必须自动拼回为「做 一个 小玩具」。
+      const r = await spawnMain('/workflow greedy-e2e --input brief=做 一个 小玩具', tmp);
+      expect(r.exitCode).toBe(0);
+      expect(r.stdout).toContain('GREEDY-BRIEF=[做 一个 小玩具]');
+      // 修复附带的用户提示：告诉用户下次记得加引号（-p 模式 warning 走 stderr 或 stdout 都算）
+      const combined = r.stdout + '\n' + r.stderr;
+      expect(combined).toContain('已自动拼回');
+    },
+    SPAWN_TIMEOUT,
+  );
 });

package/plugins/workflow-runner/test/context-files.test.ts

@@ -15,11 +15,19 @@
  * ============================================================
  */
 
-import { afterAll, beforeAll, beforeEach, describe, expect, it, mock } from 'bun:test';
-
+import {
+  afterAll,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  mock,
+} from 'bun:test';
+
+import type { Provider, Tool } from '../../../src/types.js';
 import { execLlmStep } from '../src/stepExecutors/llm.js';
 import { VarStack } from '../src/types.js';
-import type { Provider } from '../../../src/types.js';
 import type { RunContext, StepDef } from '../src/types.js';
 
 const fakeProvider: Provider = {
@@ -67,8 +75,11 @@ interface ExecuteToolCall {
 }
 const capturedExecuteToolCalls: ExecuteToolCall[] = [];
 /** mock executeTool 返回值脚本（按调用顺序）；用尽则回退到 { ok:true, content:'OK' } */
-let mockToolResults: Array<{ ok: true; content: string } | { ok: false; error: string }> = [];
+let mockToolResults: Array<
+  { ok: true; content: string } | { ok: false; error: string }
+> = [];
 
+import { chat as realChatImport } from '../../../src/llm/client.js';
 // 复用真实的 ALL_TOOLS / getToolByName（llm.ts 的白名单过滤要用），
 // 只把 executeTool 替换成 mock 版本。
 //
@@ -80,7 +91,6 @@ import {
   executeTool as realExecuteTool,
   getToolByName as realGetToolByName,
 } from '../../../src/tools/index.js';
-import { chat as realChatImport } from '../../../src/llm/client.js';
 
 // 在 mock 安装前把真实 chat 函数引用拷到值变量，避免 ESM live binding
 // 在 mock.module 后跟着变成 mock 版本（afterAll 复原才能拿到真函数）
@@ -140,7 +150,10 @@ function installChatMock(): void {
           argumentsDelta: turn.argsJson,
         };
       }
-      yield { type: 'done', stopReason: turn.kind === 'tool_call' ? 'tool_calls' : 'stop' };
+      yield {
+        type: 'done',
+        stopReason: turn.kind === 'tool_call' ? 'tool_calls' : 'stop',
+      };
     },
   }));
 }
@@ -156,7 +169,12 @@ describe('workflow-runner context_files (ADR-05 阶段 4)', () => {
     mockTurns = [];
     mockTurnIdx = 0;
     mockToolResults = [];
-    ctx = { provider: fakeProvider, history: [], cwd: process.cwd(), tools: [] };
+    ctx = {
+      provider: fakeProvider,
+      history: [],
+      cwd: process.cwd(),
+      tools: [],
+    };
   });
 
   it('pure llm 不下发工具，避免单轮设计类步骤误调工具后撞 maxTurns=1', async () => {
@@ -175,6 +193,7 @@ describe('workflow-runner context_files (ADR-05 阶段 4)', () => {
   });
 
   it('case 1: 基本 Read 引用 — tool_call 一轮 + 纯文本一轮', async () => {
+    ctx.tools = [{ name: 'Read' } as Tool];
     mockTurns = [
       {
         kind: 'tool_call',
@@ -190,8 +209,7 @@ describe('workflow-runner context_files (ADR-05 阶段 4)', () => {
       id: 'read-and-answer',
       llm: 'please summarize',
       context_files: [{ path: '/tmp/x.txt', hint: 'source data' }],
-      // v0.9：context_files 经 runQuery(TAOR) 执行，默认下发全量工具；用 allowed_tools
-      // 白名单把下发工具收敛到 Read（验证 loop.ts 的 allowedTools 过滤 + llm.ts 透传）。
+      // context_files 经 runQuery(TAOR) 执行；步骤白名单与宿主有效工具集取交集。
       allowed_tools: ['Read'],
     };
 
@@ -212,8 +230,9 @@ describe('workflow-runner context_files (ADR-05 阶段 4)', () => {
     expect(parsedArgs.file_path).toBe('/tmp/x.txt');
 
     // 第一轮 user message 包含路径和 hint
-    const firstUserMsg = (capturedChatArgs[0].messages as Array<{ role: string; content: string }>)
-      .find((m) => m.role === 'user');
+    const firstUserMsg = (
+      capturedChatArgs[0].messages as Array<{ role: string; content: string }>
+    ).find((m) => m.role === 'user');
     expect(firstUserMsg).toBeDefined();
     expect(firstUserMsg!.content).toContain('/tmp/x.txt');
     expect(firstUserMsg!.content).toContain('source data');
@@ -225,12 +244,23 @@ describe('workflow-runner context_files (ADR-05 阶段 4)', () => {
   });
 
   it('case 2: 永不收敛（每轮都调工具）→ 被 maxTurns 严格兜住，不无限循环', async () => {
+    ctx.tools = [{ name: 'Read' } as Tool];
     // v0.9 重构移除了 miniReAct 的"重复工具调用早停"，改由主 TAOR 引擎(runQuery)的
     // maxTurns 硬上限兜底。本用例验证安全属性：模型每轮都调工具、永不收敛时，chat 调用
     // 次数被 maxTurns 严格限制（不会无限循环），不再依赖已移除的重复检测。
     mockTurns = [
-      { kind: 'tool_call', callId: 'c1', name: 'Read', argsJson: '{"file_path":"/a"}' },
-      { kind: 'tool_call', callId: 'c2', name: 'Read', argsJson: '{"file_path":"/a"}' },
+      {
+        kind: 'tool_call',
+        callId: 'c1',
+        name: 'Read',
+        argsJson: '{"file_path":"/a"}',
+      },
+      {
+        kind: 'tool_call',
+        callId: 'c2',
+        name: 'Read',
+        argsJson: '{"file_path":"/a"}',
+      },
     ];
     mockToolResults = [
       { ok: true, content: 'A' },
@@ -246,13 +276,14 @@ describe('workflow-runner context_files (ADR-05 阶段 4)', () => {
 
     // 不无限循环：chat 调用次数被 maxTurns(=2) 严格兜住。
     // 撞顶后的半截产出不可信，execLlmStep 必须抛错触发 runner retry/halt。
-    await expect(drainLlm(execLlmStep(step, new VarStack(), ctx))).rejects.toThrow(
-      '达到最大轮数 2 被截断',
-    );
+    await expect(
+      drainLlm(execLlmStep(step, new VarStack(), ctx)),
+    ).rejects.toThrow('达到最大轮数 2 被截断');
     expect(capturedChatArgs.length).toBe(2);
   });
 
   it('case 3: output_schema + tools — 走 [json+tools] 前缀', async () => {
+    ctx.tools = [{ name: 'Read' } as Tool];
     mockTurns = [
       {
         kind: 'tool_call',

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

@@ -0,0 +1,314 @@
+/**
+ * 端到端验证 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;
+}

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

@@ -20,6 +20,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 { evalExpr, interpolate } from '../src/expressions.js';
 import { runWorkflow } from '../src/runner.js';
@@ -80,7 +81,14 @@ describe('E3/E2/E1 引擎层（runWorkflow 集成）', () => {
       initWorkingDir: () => tmp,
       _resetWorkingDir: () => {},
     }));
-    ctx = { provider: fakeProvider, history: [], cwd: tmp, tools: [] };
+    ctx = {
+      provider: fakeProvider,
+      history: [],
+      cwd: tmp,
+      tools: [],
+      // 显式 sessionId：resume（两次 runWorkflow 同 session）场景可预测
+      runtimeContext: createAgentRuntimeContext({ surface: 'workflow', profile: 'main', cwd: tmp, sessionId: 'test-session', owner: 'local-owner', interactiveAsk: false }),
+    };
   });
 
   afterEach(() => {

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

@@ -270,6 +270,48 @@ describe('workflows/expressions::fileExists', () => {
     expect(evalExpr('fileExists(inputs.name + ".txt")', vars)).toBe(true);
     expect(evalExpr('fileExists("videos/" + inputs.name + ".txt")', vars)).toBe(false);
   });
+
+  // 会话进入 session worktree 后，写文件的工具跟着 worktree 走（loop.ts 按
+  // sessionState.activeWorktree 重定向 cwd）。done_when / when / over 全靠
+  // fileExists，若它仍锚原 workspace，就会在空目录里找产物 —— 恒 false，
+  // 工作流被判失败并反复重试，而产物其实好好躺在 worktree 里。
+  it('resolveCwd 让 fileExists 跟随 session worktree 而非原 workspace', () => {
+    const worktree = mkdtempSync(join(tmpdir(), 'wf-expr-wt-'));
+    try {
+      // 产物只存在于 worktree，workspace 是空的。
+      writeFileSync(join(worktree, 'out.md'), 'artifact');
+
+      const vars = new VarStack();
+      // 未设 resolveCwd：锚 workspace（旧行为）→ 找不到。
+      expect(evalExpr('fileExists("out.md")', vars)).toBe(false);
+
+      // 设了 resolveCwd：锚 worktree → 命中。
+      vars.resolveCwd = () => worktree;
+      expect(evalExpr('fileExists("out.md")', vars)).toBe(true);
+
+      // 解析器是函数而非快照：运行途中退出 worktree 后立刻跟着变回去。
+      let active: string | undefined = worktree;
+      vars.resolveCwd = () => active ?? tmp;
+      expect(evalExpr('fileExists("out.md")', vars)).toBe(true);
+      active = undefined;
+      expect(evalExpr('fileExists("out.md")', vars)).toBe(false);
+    } finally {
+      rmSync(worktree, { recursive: true, force: true });
+    }
+  });
+
+  it('resolveCwd 下越界守卫仍以该 cwd 为界', () => {
+    const worktree = mkdtempSync(join(tmpdir(), 'wf-expr-wt2-'));
+    try {
+      writeFileSync(join(tmp, 'outside.txt'), 'x');
+      const vars = new VarStack();
+      vars.resolveCwd = () => worktree;
+      // 换锚点后，原 workspace 的文件反而成了「界外」，fail-closed 仍生效。
+      expect(evalExpr('fileExists("../outside.txt")', vars)).toBe(false);
+    } finally {
+      rmSync(worktree, { recursive: true, force: true });
+    }
+  });
 });
 
 describe('workflows/expressions::readJson', () => {

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

@@ -25,6 +25,7 @@ describe('框架侧：runCommand 必须带上 host', () => {
     expect(call).toContain('host:');
     expect(call).toContain('computerRun');
     expect(call).toContain('browserRun');
+    expect(call).toContain('executeTool: options.executeTool');
   });
 
   test('PluginContext 用 Pick<ToolCallContext> 绑定，而不是重新声明', async () => {
@@ -40,9 +41,14 @@ describe('能力常量单一来源', () => {
   test('loader 的白名单与 types 的 HostCapability 一致', async () => {
     // 两处不一致的表现是：yaml 写了某个能力、loader 放行、运行时却识别不了，
     // 或反过来 loader 拦掉一个其实支持的能力。都属于静默错。
-    const types = await Bun.file(new URL('../src/types.ts', import.meta.url)).text();
-    const declared = /export type HostCapability =([^;]+);/.exec(types)?.[1] ?? '';
-    const fromTypes = [...declared.matchAll(/'([a-z]+)'/g)].map((m) => m[1]).sort();
+    const types = await Bun.file(
+      new URL('../src/types.ts', import.meta.url),
+    ).text();
+    const declared =
+      /export type HostCapability =([^;]+);/.exec(types)?.[1] ?? '';
+    const fromTypes = [...declared.matchAll(/'([a-z]+)'/g)]
+      .map((m) => m[1])
+      .sort();
     expect(fromTypes).toEqual([...VALID_HOST_CAPABILITIES].sort());
   });
 });

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

@@ -52,7 +52,7 @@ describe('workflows/illustrate.yaml（网上抓图配图）', () => {
     expect(inputs.find((i) => i.name === 'topic')?.greedy).toBe(true);
     expect(inputs.find((i) => i.name === 'count')?.default).toBe(3);
     expect(inputs.find((i) => i.name === 'min_candidates')?.default).toBe(6);
-    expect(def.artifacts).toContain('./build/illustrations.json');
+    expect(def.artifacts).toContain('out/illustrate/${session}/build/illustrations.json');
   });
 
   it('关键步齐全且顺序正确：三家图搜 → 守门 → 下载 → 打分 → 选优 → 报告', async () => {
@@ -152,7 +152,7 @@ describe('workflows/illustrate.yaml（网上抓图配图）', () => {
     expect(a).toContain('illustrations.json');
     expect(String(sel?.done_when)).toContain('illustrations.json');
     for (const t of ['Glob', 'Read', 'Write']) expect(sel?.allowed_tools).toContain(t);
-    expect(sel?.artifacts).toContain('./build/illustrations.json');
+    expect(sel?.artifacts).toContain('out/illustrate/${session}/build/illustrations.json');
   });
 
   it('用到本轮新增通用件：parseJson 表达式 + Download 工具', async () => {