minimal-agent 0.12.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/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/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 () => {

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

@@ -61,6 +61,25 @@ describe('parseWorkflowArgs / tokenizeArgs 边界行为冻结', () => {
     expect(r.inputs).toEqual({ topic: 'AI 教程' });
   });
 
+  test('引号在 = 后的 KV：value 含空格也完整捕获（回归：曾按空白硬切+引号残留）', () => {
+    // 用户 shell 习惯 `--input topic="带空格 的值"` —— 引号在 token 内部（= 之后），
+    // 曾被 tokenizeArgs 按空白切分 → 值截断 + 引号残留 + 散落 positional。
+    const r = parseWorkflowArgs(
+      'hello --input topic="比特币量化 长线 短线策略" --input depth=standard',
+    );
+    expect(r.inputs).toEqual({
+      topic: '比特币量化 长线 短线策略',
+      depth: 'standard',
+    });
+    expect(r.positional).toEqual([]);
+  });
+
+  test('单引号在 = 后同理支持', () => {
+    const r = parseWorkflowArgs("hello --input topic='AI 教程 入门'");
+    expect(r.inputs).toEqual({ topic: 'AI 教程 入门' });
+    expect(r.positional).toEqual([]);
+  });
+
   test('未知 -- flag 跳过其后一个 token（保守解析）', () => {
     const r = parseWorkflowArgs('hello --foo bar alice');
     // --foo bar 被吃掉，alice 进 positional

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

@@ -93,11 +93,11 @@ describe('workflows/ppt.yaml（统一素材摄取·素材驱动）', () => {
       expect(String(s.title)).toContain('/22');
     }
 
-    // 收尾 echo；artifacts 只列最终交付物、不在被 rm 的 ./build 下
+    // 收尾 echo；artifacts 只列最终交付物、不在被 rm 的 out/ppt/${session}/build 下
     expect(def.steps.find((s) => s.id === 'final_report')?.type).toBe('echo');
     const declared = def.artifacts ?? [];
-    expect(declared).toContain('./out/deck.pptx');
-    for (const a of declared) expect(a.startsWith('./build')).toBe(false);
+    expect(declared).toContain('out/ppt/${session}/deck.pptx');
+    for (const a of declared) expect(a.startsWith('out/ppt/${session}/build')).toBe(false);
   });
 
   it('stage0_clarify：样式推荐按配色感知、覆盖全部 13 个 VI（不再只露 6 个）', async () => {
@@ -205,7 +205,7 @@ describe('workflows/ppt.yaml（统一素材摄取·素材驱动）', () => {
 
     const repair = def.steps.find((s) => s.id === 'stage_draft_coverage_repair');
     expect(String(repair?.when)).toContain('draft_coverage_report.json');
-    expect(String(repair?.when)).toContain("readJson('./build/draft_coverage_report.json', 'ok') == false");
+    expect(String(repair?.when)).toContain("readJson('out/ppt/${session}/build/draft_coverage_report.json', 'ok') == false");
     // 用户点名最高优先级问题：fast/best 都要跑，when 不能限死 quality=='best'。
     expect(String(repair?.when)).not.toContain("quality == 'best'");
     expect(String(repair?.agent)).toContain('draft_coverage_report.md');
@@ -482,7 +482,7 @@ describe('workflows/ppt.yaml（统一素材摄取·素材驱动）', () => {
     // ① 摄取后跑确定性规划（在 design 之前，data 已齐）
     const ids = def.steps.map((s) => s.id);
     const am = def.steps.find((s) => s.id === 'stage_assemble_material');
-    expect(String(am?.args?.command)).toContain('plan_source_layout.py --build ./build');
+    expect(String(am?.args?.command)).toContain('plan_source_layout.py --build out/ppt/${session}/build');
     expect(ids.indexOf('stage_assemble_material')).toBeLessThan(ids.indexOf('stage_design_doc'));
 
     // ② 设计步「读规划、照它执行」——逐图心算被收成确定性
@@ -516,7 +516,7 @@ describe('workflows/ppt.yaml（统一素材摄取·素材驱动）', () => {
     expect(ga).toContain('--ensure-page-backgrounds');
     expect(ga).toContain('image_prompt_rewrite.py');
     expect(ga).toContain('image_plan_lint.py');
-    expect(ga).toContain('touch ./build/img_route_ok');
+    expect(ga).toContain('touch out/ppt/${session}/build/img_route_ok');
     // when 放宽：img_plan 存在 或 规划里有待增强图 —— 表达式可被引擎求值（不抛、不畸形）
     const whenExpr = String(gate?.when);
     expect(whenExpr).toContain('enhance_entries');
@@ -664,8 +664,8 @@ describe('workflows/ppt.yaml（统一素材摄取·素材驱动）', () => {
     expect(gen?.agent).toBeUndefined();
     expect(gen?.tool).toBe('GenerateImage');
     expect(gen?.tool).not.toBe('Bash');
-    expect(String(gen?.args?.plan)).toBe('./build/img_plan.json');
-    expect(String(gen?.args?.assets)).toBe('./build/assets');
+    expect(String(gen?.args?.plan)).toBe('out/ppt/${session}/build/img_plan.json');
+    expect(String(gen?.args?.assets)).toBe('out/ppt/${session}/build/assets');
     expect(String(gen?.args?.timeout_ms)).toBe('300000');
     expect(String(gen?.args?.wall_budget_ms)).toBe('3600000');
     expect(gen?.onError).toBe('continue');
@@ -673,7 +673,7 @@ describe('workflows/ppt.yaml（统一素材摄取·素材驱动）', () => {
     const quality = def.steps.find((s) => s.id === 'stage_image_quality_gate');
     expect(quality?.tool).toBe('GenerateImage');
     expect(String(quality?.when)).toContain('image_generation_report.json');
-    expect(String(quality?.args?.retry_degraded_report)).toBe('./build/image_generation_report.json');
+    expect(String(quality?.args?.retry_degraded_report)).toBe('out/ppt/${session}/build/image_generation_report.json');
     expect(String(quality?.title)).toContain('fast一轮');
     expect(quality?.args?.max_rounds).toBe(1);
 
@@ -705,7 +705,7 @@ describe('workflows/ppt.yaml（统一素材摄取·素材驱动）', () => {
     const imageRetry = def.steps.find((s) => s.id === 'stage_generated_image_retry');
     expect(imageRetry?.tool).toBe('GenerateImage');
     expect(String(imageRetry?.when)).toBe('false');
-    expect(String(imageRetry?.args?.retry_degraded_report)).toBe('./build/generated_image_semantic_retry_report.json');
+    expect(String(imageRetry?.args?.retry_degraded_report)).toBe('out/ppt/${session}/build/generated_image_semantic_retry_report.json');
     expect(String(imageRetry?.args?.max_rounds)).toBe('3');
 
     const visualGate = def.steps.find((s) => s.id === 'stage_visual_quality_gate');
@@ -753,7 +753,7 @@ describe('workflows/ppt.yaml（统一素材摄取·素材驱动）', () => {
     // 完全同参双跑、且视觉门达轮数已带残留放行）——style 检查唯一跑点在
     // stage_visual_quality_gate（fast/best 统一 2 轮修复），导出只验哨兵。
     expect(String(exp?.args?.command)).not.toContain('deck_visual_style_check.py');
-    expect(String(exp?.args?.command)).toContain('test -f ./build/visual_quality_ok');
+    expect(String(exp?.args?.command)).toContain('test -f out/ppt/${session}/build/visual_quality_ok');
     expect(exp?.done_when).toBeUndefined();
 
     const design = def.steps.find((s) => s.id === 'stage_design_doc');
@@ -829,7 +829,7 @@ describe('workflows/ppt.yaml（统一素材摄取·素材驱动）', () => {
     expect(String(probe?.args?.command)).toContain('build_probe.json');
     expect(String(probe?.args?.command)).toContain('build_complete');
     const batchStep = dos.find((s) => s.id === 'build_batch');
-    expect(String(batchStep?.when)).toContain("!fileExists('./build/build_complete')");
+    expect(String(batchStep?.when)).toContain("!fileExists('out/ppt/${session}/build/build_complete')");
     expect(batchStep?.maxTurns).toBeLessThanOrEqual(24);
     expect(batchStep?.max_retries).toBe(1);
     const batch = String(batchStep?.agent);
@@ -840,7 +840,7 @@ describe('workflows/ppt.yaml（统一素材摄取·素材驱动）', () => {
     expect(batch).toContain('次顶层'); // 插图图层：文本之下、背景之上
     expect(batch).toContain('遮挡');
     const done = dos.find((s) => s.id === 'build_done');
-    expect(String(done?.when)).toContain("fileExists('./build/build_complete')");
+    expect(String(done?.when)).toContain("fileExists('out/ppt/${session}/build/build_complete')");
   });
 
   it('fast 链路清理旧运行哨兵，且说明/报告顺序为先生图后构建', async () => {
@@ -866,12 +866,12 @@ describe('workflows/ppt.yaml（统一素材摄取·素材驱动）', () => {
     ]) {
       expect(cmd).toContain(marker);
     }
-    expect(cmd).toContain('rm -rf ./build/export ./build/generated-image-reviews');
+    expect(cmd).toContain('rm -rf out/ppt/${session}/build/export out/ppt/${session}/build/generated-image-reviews');
 
     const cleanup = def.steps.find((s) => s.id === 'cleanup_intermediates');
     const cleanupCmd = String(cleanup?.args?.command);
     expect(cleanupCmd).toContain('inputs.debug_keep_build');
-    expect(cleanupCmd).toContain('rm -rf ./build');
+    expect(cleanupCmd).toContain('rm -rf out/ppt/${session}/build');
     expect(cleanupCmd).toContain('debug_keep_build=true');
     expect(cleanupCmd).not.toContain('[TEMP]');
     expect(cleanupCmd).not.toContain('上线前');

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

@@ -128,11 +128,12 @@ describe('ralph-loop.yaml 端到端（while + fresh_context + 哨兵协议）',
     expect(p2).not.toContain('我做了规划');
 
     // 教训档案恰好一条、不重复（iter1 无 learning 标签时 extract → '' 不得重复累积）
-    // 注意成功后状态目录被归档为 ralph-loop.done
+    // learnings 是 workflow 级共享存档，写在 ralph-loop/ 下（Phase 2 父目录不参与归档改名；
+    // 状态实例归档为 ralph-loop/<taskId>.done/）
     const learningsPath = join(
       tmp,
       '.minimal-agent-workflow',
-      'ralph-loop.done',
+      'ralph-loop',
       'learnings.md',
     );
     expect(existsSync(learningsPath)).toBe(true);