minimal-agent 0.12.0 → 0.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minimal-agent",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Bun-first 的本地 Agent 内核，支持工具、插件、工作流、上下文压缩、长期记忆与 OpenAI 兼容接口；Tauri 桌面宿主和 Node.js npm 发布可复用同一内核",
   "license": "SEE LICENSE IN LICENSE",
   "author": "Bill Wang <leiwang0359@gmail.com>",
@@ -131,11 +131,12 @@
     "prepublishOnly": "bun run clean && bun run build"
   },
   "dependencies": {
+    "ccxt": "^4.5.58",
     "diff": "^8.0.2",
     "fast-glob": "^3.3.2",
     "ink": "^5.0.1",
     "marked": "^18.0.6",
-    "pdfjs-dist": "4.10.38",
+    "pdfjs-dist": "^6.2.108",
     "react": "^18.3.1",
     "turndown": "^7.2.4",
     "vscode-jsonrpc": "^8.2.1",

package/plugins/workflow-runner/src/expressions.js

@@ -40,6 +40,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join, isAbsolute } from 'node:path';
 import { getWorkingDir } from '../../../src/plugin-sdk.js';
+import { DANGEROUS_KEYS, isAbsWithinCwd } from './types.js';
 const PUNCT2 = new Set(['==', '!=', '>=', '<=', '&&', '||']);
 const PUNCT1 = new Set(['(', ')', '[', ']', ',', '.', '!', '>', '<', '+', '?', ':']);
 function tokenize(src) {
@@ -143,12 +144,25 @@ function isPunct(c, v) {
     const t = peek(c);
     return !!t && t.kind === 'punct' && t.value === v;
 }
+/**
+ * 读磁盘的内置函数（fileExists / readJson）的锚点。
+ * 必须和写入侧同源：进了 session worktree 后产物落在 worktree 里，
+ * 这里若仍锚原 workspace，done_when 会在空目录里找文件而恒判 false。
+ */
+function cwdOf(vars) {
+    return vars.resolveCwd?.() ?? getWorkingDir();
+}
 const BUILTINS = {
-    fileExists(args) {
+    fileExists(args, cwd) {
         const p = String(args[0] ?? '');
         if (!p)
             return false;
-        const abs = isAbsolute(p) ? p : join(getWorkingDir(), p);
+        const abs = isAbsolute(p) ? p : join(cwd, p);
+        // 安全守卫：越出 cwd 的路径视为"不存在"（fail-closed，与 readJson 同策略）。
+        // 不可信 YAML（模板库/他人分享）可能带 fileExists('/etc/passwd') 做信息刺探，
+        // 这里与 cleanupDeclaredArtifacts 保持一致：只允许操作 cwd 下的文件。
+        if (!isAbsWithinCwd(cwd, abs))
+            return false;
         return existsSync(abs);
     },
     length(args) {
@@ -247,16 +261,19 @@ const BUILTINS = {
             return 'null';
         }
     },
-    // 读磁盘 JSON 文件并取值：path 相对 getWorkingDir()（绝对路径原样）；给了 key
-    // 则返回顶层 obj[key]，否则返回整值。缺文件 / 坏 JSON / 键不存在 → null
+    // 读磁盘 JSON 文件并取值：path 相对当前有效 cwd（绝对路径先经 cwd 安全校验，
+    // 越界直接 null，与 fileExists 同 fail-closed 策略）；给了 key 则返回顶层
+    // obj[key]，否则返回整值。缺文件 / 坏 JSON / 键不存在 / 越界 → null
     //（与 match/extract 同「不抛」哲学）。动机：让确定性脚本产出的 manifest
     //（如 source_assets.json）直接驱动工作流 for-each / branch —— 填补「磁盘
     // 结构化数据 → 控制流」的空白（与 fileExists 平级的基础能力）。
-    readJson(args) {
+    readJson(args, cwd) {
         const p = String(args[0] ?? '');
         if (!p)
             return null;
-        const abs = isAbsolute(p) ? p : join(getWorkingDir(), p);
+        const abs = isAbsolute(p) ? p : join(cwd, p);
+        if (!isAbsWithinCwd(cwd, abs))
+            return null; // 越界 → null（不抛，fail-closed）
         try {
             // 剥前导 BOM：某些工具/重定向写出的 JSON 带 BOM，JSON.parse 会因此抛错。
             let raw = readFileSync(abs, 'utf8');
@@ -439,7 +456,7 @@ function parsePrimary(c, vars) {
             const fn = BUILTINS[t.value];
             if (!fn)
                 throw new Error(`未知函数 "${t.value}"。白名单：${Object.keys(BUILTINS).join(', ')}`);
-            return fn(argv);
+            return fn(argv, cwdOf(vars));
         }
         // 字面常量
         if (t.value === 'true')
@@ -608,8 +625,12 @@ export function interpolateDeep(value, vars, opts) {
     if (value && typeof value === 'object') {
         const out = {};
         for (const [k, v] of Object.entries(value)) {
-            // 注意：key 也插值（loop 里 `hook_${idx}` 这种），但只对字符串 key 有意义
+            // 注意：key 也插值（loop 里 `hook_${idx}` 这种），但只对字符串 key 有意义；
+            // 插值后的 key 若命中危险键（__proto__/constructor/prototype）→ 直接跳过不写，
+            // 防止经动态 key 注入原型链属性（与 VarStack 防线保持一致）。
             const newKey = interpolate(k, vars, opts);
+            if (DANGEROUS_KEYS.has(newKey))
+                continue;
             out[newKey] = interpolateDeep(v, vars, opts);
         }
         return out;

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

@@ -42,7 +42,7 @@ import { existsSync, readFileSync } from 'node:fs';
 import { join, isAbsolute } from 'node:path';
 
 import { getWorkingDir } from '../../../src/plugin-sdk.js';
-import type { VarStack } from './types.js';
+import { DANGEROUS_KEYS, isAbsWithinCwd, type VarStack } from './types.js';
 
 // ---------------- Tokenizer ----------------
 
@@ -160,11 +160,24 @@ function isPunct(c: Cursor, v: string): boolean {
   return !!t && t.kind === 'punct' && t.value === v;
 }
 
-const BUILTINS: Record<string, (args: unknown[]) => unknown> = {
-  fileExists(args) {
+/**
+ * 读磁盘的内置函数（fileExists / readJson）的锚点。
+ * 必须和写入侧同源：进了 session worktree 后产物落在 worktree 里，
+ * 这里若仍锚原 workspace，done_when 会在空目录里找文件而恒判 false。
+ */
+function cwdOf(vars: VarStack): string {
+  return vars.resolveCwd?.() ?? getWorkingDir();
+}
+
+const BUILTINS: Record<string, (args: unknown[], cwd: string) => unknown> = {
+  fileExists(args, cwd) {
     const p = String(args[0] ?? '');
     if (!p) return false;
-    const abs = isAbsolute(p) ? p : join(getWorkingDir(), p);
+    const abs = isAbsolute(p) ? p : join(cwd, p);
+    // 安全守卫：越出 cwd 的路径视为"不存在"（fail-closed，与 readJson 同策略）。
+    // 不可信 YAML（模板库/他人分享）可能带 fileExists('/etc/passwd') 做信息刺探，
+    // 这里与 cleanupDeclaredArtifacts 保持一致：只允许操作 cwd 下的文件。
+    if (!isAbsWithinCwd(cwd, abs)) return false;
     return existsSync(abs);
   },
   length(args) {
@@ -254,15 +267,17 @@ const BUILTINS: Record<string, (args: unknown[]) => unknown> = {
       return 'null';
     }
   },
-  // 读磁盘 JSON 文件并取值：path 相对 getWorkingDir()（绝对路径原样）；给了 key
-  // 则返回顶层 obj[key]，否则返回整值。缺文件 / 坏 JSON / 键不存在 → null
+  // 读磁盘 JSON 文件并取值：path 相对当前有效 cwd（绝对路径先经 cwd 安全校验，
+  // 越界直接 null，与 fileExists 同 fail-closed 策略）；给了 key 则返回顶层
+  // obj[key]，否则返回整值。缺文件 / 坏 JSON / 键不存在 / 越界 → null
   //（与 match/extract 同「不抛」哲学）。动机：让确定性脚本产出的 manifest
   //（如 source_assets.json）直接驱动工作流 for-each / branch —— 填补「磁盘
   // 结构化数据 → 控制流」的空白（与 fileExists 平级的基础能力）。
-  readJson(args) {
+  readJson(args, cwd) {
     const p = String(args[0] ?? '');
     if (!p) return null;
-    const abs = isAbsolute(p) ? p : join(getWorkingDir(), p);
+    const abs = isAbsolute(p) ? p : join(cwd, p);
+    if (!isAbsWithinCwd(cwd, abs)) return null; // 越界 → null（不抛，fail-closed）
     try {
       // 剥前导 BOM：某些工具/重定向写出的 JSON 带 BOM，JSON.parse 会因此抛错。
       let raw = readFileSync(abs, 'utf8');
@@ -436,7 +451,7 @@ function parsePrimary(c: Cursor, vars: VarStack): unknown {
       eat(c);
       const fn = BUILTINS[t.value];
       if (!fn) throw new Error(`未知函数 "${t.value}"。白名单：${Object.keys(BUILTINS).join(', ')}`);
-      return fn(argv);
+      return fn(argv, cwdOf(vars));
     }
     // 字面常量
     if (t.value === 'true') return true;
@@ -612,8 +627,11 @@ export function interpolateDeep<T>(
   if (value && typeof value === 'object') {
     const out: Record<string, unknown> = {};
     for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
-      // 注意：key 也插值（loop 里 `hook_${idx}` 这种），但只对字符串 key 有意义
+      // 注意：key 也插值（loop 里 `hook_${idx}` 这种），但只对字符串 key 有意义；
+      // 插值后的 key 若命中危险键（__proto__/constructor/prototype）→ 直接跳过不写，
+      // 防止经动态 key 注入原型链属性（与 VarStack 防线保持一致）。
       const newKey = interpolate(k, vars, opts);
+      if (DANGEROUS_KEYS.has(newKey)) continue;
       out[newKey] = interpolateDeep(v, vars, opts);
     }
     return out as unknown as T;

package/plugins/workflow-runner/src/index.js

@@ -53,7 +53,20 @@ export function parseWorkflowArgs(rawArgs) {
     }
     return { name, inputs, positional };
 }
-/** 简单 token 化：双引号包裹的整体当一个 token；其它按空白切。 */
+/**
+ * shell 风格 token 化：空白切分 token；引号（' 或 "）在 token **任意位置**（不只开头）
+ * 出现即进入引号模式——引号内的空白不切分、引号字符本身被剥离。
+ *
+ * 修复：`--input topic="带空格的值"`（引号在 `=` 后，token 开头是 `t`）曾被按空白
+ * 硬切 → 值截断 + 引号残留（实测 inputs.topic 带 `"` 尾，positional 里散落被拆的字）。
+ * 现在 token 内任意位置的引号都正确分组。
+ *
+ * 边界语义（被 parseWorkflowArgs.test.ts 冻结）：
+ *   - 未闭合引号：剩余部分并入当前 token（不报错）
+ *   - 双引号内的单引号是字面量（不触发嵌套）
+ *   - 反斜杠不转义（`a\"b` 中 `"` 仍开启引号模式，行为变化但测试用 toBeDefined 容错）
+ *   - 连续空白合并、`""` 产生空 token
+ */
 function tokenizeArgs(s) {
     const out = [];
     let i = 0;
@@ -62,24 +75,27 @@ function tokenizeArgs(s) {
             i++;
         if (i >= s.length)
             break;
-        if (s[i] === '"' || s[i] === "'") {
-            const q = s[i];
-            i++;
-            let acc = '';
-            while (i < s.length && s[i] !== q) {
-                acc += s[i++];
+        let acc = '';
+        while (i < s.length) {
+            const c = s[i];
+            if (c === '"' || c === "'") {
+                // 引号模式：收集到闭合引号，引号内空白保留
+                const q = c;
+                i++;
+                while (i < s.length && s[i] !== q)
+                    acc += s[i++];
+                if (i < s.length)
+                    i++; // 跳过闭合引号
+            }
+            else if (/\s/.test(c)) {
+                break;
             }
-            if (i < s.length)
+            else {
+                acc += c;
                 i++;
-            out.push(acc);
-        }
-        else {
-            let acc = '';
-            while (i < s.length && !/\s/.test(s[i])) {
-                acc += s[i++];
             }
-            out.push(acc);
         }
+        out.push(acc);
     }
     return out;
 }
@@ -167,12 +183,17 @@ export async function* runWorkflowFromCommand(rawArgs, opts) {
     //   - 默认：严格按"第 i 个位置参数 ↔ def.inputs[i]"对应。
     // --input k=v 显式优先：已显式的 input 不被位置参数覆盖（对应位置参数被丢弃，会 warn）。
     const overriddenByKV = [];
+    const greedyNotes = [];
     const greedyFirst = def.inputs?.[0]?.greedy === true;
     if (greedyFirst && def.inputs && positional.length > 0) {
         const greedyName = def.inputs[0].name;
         if (greedyName in rawInputs) {
-            // 首参已被 --input 占位 → 整串位置参数被忽略
-            overriddenByKV.push(`${greedyName}=${JSON.stringify(rawInputs[greedyName])} (位置参数 ${JSON.stringify(positional.join(' '))} 被忽略)`);
+            // 首参已由 --input 提供时，位置参数仍按贪婪语义【拼回】首参末尾--
+            // 含空格的值未加引号时会被 shell 拆开（--input topic=A B C 只有 A 进 KV，
+            // B C 散落成位置参数），静默丢弃曾把整段中文调研主题截成半句、
+            // 连锁触发任务仲裁误判 new-task 清空全部产物。
+            rawInputs[greedyName] = [rawInputs[greedyName], ...positional].join(' ');
+            greedyNotes.push(`${greedyName}：--input 值未加引号被拆成 ${positional.length} 段位置参数，已自动拼回（下次请写 --input "${greedyName}=完整值"）`);
         }
         else {
             // 贪婪吸收：整句进首参（空格 join 还原用户原话，不逐位拆映射）
@@ -202,6 +223,13 @@ export async function* runWorkflowFromCommand(rawArgs, opts) {
             message: `⚠ 忽略了 ${dropped.length} 个多余位置参数: ${dropped.map((d) => JSON.stringify(d)).join(' ')}（workflow "${name}" 只声明了 ${def.inputs.length} 个 input）`,
         };
     }
+    // warn：贪婪首参的 --input 值被 shell 拆开后自动拼回
+    if (greedyNotes.length > 0) {
+        yield {
+            type: 'warning',
+            message: `⚠ ${greedyNotes.join('；')}`,
+        };
+    }
     // warn：位置参数被 --input 覆盖
     if (overriddenByKV.length > 0) {
         yield {

package/plugins/workflow-runner/src/index.ts

@@ -91,29 +91,43 @@ export function parseWorkflowArgs(rawArgs: string): {
   return { name, inputs, positional };
 }
 
-/** 简单 token 化：双引号包裹的整体当一个 token；其它按空白切。 */
+/**
+ * shell 风格 token 化：空白切分 token；引号（' 或 "）在 token **任意位置**（不只开头）
+ * 出现即进入引号模式——引号内的空白不切分、引号字符本身被剥离。
+ *
+ * 修复：`--input topic="带空格的值"`（引号在 `=` 后，token 开头是 `t`）曾被按空白
+ * 硬切 → 值截断 + 引号残留（实测 inputs.topic 带 `"` 尾，positional 里散落被拆的字）。
+ * 现在 token 内任意位置的引号都正确分组。
+ *
+ * 边界语义（被 parseWorkflowArgs.test.ts 冻结）：
+ *   - 未闭合引号：剩余部分并入当前 token（不报错）
+ *   - 双引号内的单引号是字面量（不触发嵌套）
+ *   - 反斜杠不转义（`a\"b` 中 `"` 仍开启引号模式，行为变化但测试用 toBeDefined 容错）
+ *   - 连续空白合并、`""` 产生空 token
+ */
 function tokenizeArgs(s: string): string[] {
   const out: string[] = [];
   let i = 0;
   while (i < s.length) {
     while (i < s.length && /\s/.test(s[i])) i++;
     if (i >= s.length) break;
-    if (s[i] === '"' || s[i] === "'") {
-      const q = s[i];
-      i++;
-      let acc = '';
-      while (i < s.length && s[i] !== q) {
-        acc += s[i++];
-      }
-      if (i < s.length) i++;
-      out.push(acc);
-    } else {
-      let acc = '';
-      while (i < s.length && !/\s/.test(s[i])) {
-        acc += s[i++];
+    let acc = '';
+    while (i < s.length) {
+      const c = s[i];
+      if (c === '"' || c === "'") {
+        // 引号模式：收集到闭合引号，引号内空白保留
+        const q = c;
+        i++;
+        while (i < s.length && s[i] !== q) acc += s[i++];
+        if (i < s.length) i++; // 跳过闭合引号
+      } else if (/\s/.test(c)) {
+        break;
+      } else {
+        acc += c;
+        i++;
       }
-      out.push(acc);
     }
+    out.push(acc);
   }
   return out;
 }
@@ -219,13 +233,18 @@ export async function* runWorkflowFromCommand(
   //   - 默认：严格按"第 i 个位置参数 ↔ def.inputs[i]"对应。
   // --input k=v 显式优先：已显式的 input 不被位置参数覆盖（对应位置参数被丢弃，会 warn）。
   const overriddenByKV: string[] = [];
+  const greedyNotes: string[] = [];
   const greedyFirst = def.inputs?.[0]?.greedy === true;
   if (greedyFirst && def.inputs && positional.length > 0) {
     const greedyName = def.inputs[0].name;
     if (greedyName in rawInputs) {
-      // 首参已被 --input 占位 → 整串位置参数被忽略
-      overriddenByKV.push(
-        `${greedyName}=${JSON.stringify(rawInputs[greedyName])} (位置参数 ${JSON.stringify(positional.join(' '))} 被忽略)`,
+      // 首参已由 --input 提供时，位置参数仍按贪婪语义【拼回】首参末尾--
+      // 含空格的值未加引号时会被 shell 拆开（--input topic=A B C 只有 A 进 KV，
+      // B C 散落成位置参数），静默丢弃曾把整段中文调研主题截成半句、
+      // 连锁触发任务仲裁误判 new-task 清空全部产物。
+      rawInputs[greedyName] = [rawInputs[greedyName], ...positional].join(' ');
+      greedyNotes.push(
+        `${greedyName}：--input 值未加引号被拆成 ${positional.length} 段位置参数，已自动拼回（下次请写 --input "${greedyName}=完整值"）`,
       );
     } else {
       // 贪婪吸收：整句进首参（空格 join 还原用户原话，不逐位拆映射）
@@ -256,6 +275,13 @@ export async function* runWorkflowFromCommand(
       message: `⚠ 忽略了 ${dropped.length} 个多余位置参数: ${dropped.map((d) => JSON.stringify(d)).join(' ')}（workflow "${name}" 只声明了 ${def.inputs.length} 个 input）`,
     };
   }
+  // warn：贪婪首参的 --input 值被 shell 拆开后自动拼回
+  if (greedyNotes.length > 0) {
+    yield {
+      type: 'warning',
+      message: `⚠ ${greedyNotes.join('；')}`,
+    };
+  }
   // warn：位置参数被 --input 覆盖
   if (overriddenByKV.length > 0) {
     yield {

package/plugins/workflow-runner/src/recovery.js

@@ -81,8 +81,15 @@ export async function* runRecovery(step, vars, ctx, errorMsg) {
         : recoverPrompt + schemaHint;
     try {
         // 委托 TAOR 引擎执行（共享消费层 runStepQuery）——事件透传给 UI（显示恢复进度）。
-        // 注意剥掉 step 的 allowed_tools 白名单：原步收敛工具是为弱模型聚焦，
-        // 恢复 agent 的职责正是「随机应变换路径」，要全工具箱（保持 v0.9 行为）。
+        // 注意剥掉 step 的 allowed_tools 白名单：【allowed_tools 本身不是安全边界，是弱模型聚焦优化】
+        // （原步限定一小撮工具给能力弱的模型，避免它瞎试跑遍所有工具）。
+        // 恢复 agent 的职责正是「随机应变换路径」，需要它能调用原步没考虑过的替代工具，
+        // 所以这里解除聚焦限制。真正的安全边界在**另外两层**，此处没有动：
+        //   1. `StepDef.uses: [browser|computer]` —— 宿主能力切片（buildWorkflowToolContext 仍生效），
+        //      原步没声明 computer 的话，恢复 agent 也调不通 ComputerUse。
+        //   2. `ctx.tools` —— 插件层按 runtime + 宿主白名单裁剪后的有效工具集合，
+        //      无论 allowed_tools 写什么都不能超出它。
+        // 保持 v0.9 行为（放开 allowed_tools），但明确安全层次不发生变化。
         const { rawText, sawLlmError, sawMaxTurns, llmErrorDetail } = yield* runStepQuery(fullPrompt, { ...step, allowed_tools: undefined }, ctx, { maxTurns: step.maxTurns ?? 25 });
         // 恢复是兜底路径：无论 provider 失败还是模型空答，都按「没救回」返回
         // ok:false（不抛重试——retry 在进入 recover 前已用尽）；只是归因更诚实。

package/plugins/workflow-runner/src/recovery.ts

@@ -104,8 +104,15 @@ export async function* runRecovery(
 
   try {
     // 委托 TAOR 引擎执行（共享消费层 runStepQuery）——事件透传给 UI（显示恢复进度）。
-    // 注意剥掉 step 的 allowed_tools 白名单：原步收敛工具是为弱模型聚焦，
-    // 恢复 agent 的职责正是「随机应变换路径」，要全工具箱（保持 v0.9 行为）。
+    // 注意剥掉 step 的 allowed_tools 白名单：【allowed_tools 本身不是安全边界，是弱模型聚焦优化】
+    // （原步限定一小撮工具给能力弱的模型，避免它瞎试跑遍所有工具）。
+    // 恢复 agent 的职责正是「随机应变换路径」，需要它能调用原步没考虑过的替代工具，
+    // 所以这里解除聚焦限制。真正的安全边界在**另外两层**，此处没有动：
+    //   1. `StepDef.uses: [browser|computer]` —— 宿主能力切片（buildWorkflowToolContext 仍生效），
+    //      原步没声明 computer 的话，恢复 agent 也调不通 ComputerUse。
+    //   2. `ctx.tools` —— 插件层按 runtime + 宿主白名单裁剪后的有效工具集合，
+    //      无论 allowed_tools 写什么都不能超出它。
+    // 保持 v0.9 行为（放开 allowed_tools），但明确安全层次不发生变化。
     const { rawText, sawLlmError, sawMaxTurns, llmErrorDetail } =
       yield* runStepQuery(
         fullPrompt,

package/plugins/workflow-runner/src/runner.js

@@ -25,7 +25,8 @@ import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { dlog, getWorkingDir } from '../../../src/plugin-sdk.js';
 import { evalExpr, interpolate } from './expressions.js';
-import { buildTaskArbitrator, isContinuationPhrase } from './taskIdentity.js';
+import { effectiveWorkflowCwd } from './toolRuntime.js';
+import { buildTaskArbitrator, DEFAULT_SESSION_ID, generateDefaultSessionId, isContinuationPhrase, sanitizeWorkflowDirName } from './taskIdentity.js';
 import { execAgentStep } from './stepExecutors/agent.js';
 import { execAssertStep } from './stepExecutors/assert.js';
 import { execVerifyStep } from './stepExecutors/verify.js';
@@ -153,7 +154,7 @@ async function* dispatchActionStep(step, vars, ctx) {
     if (step.type === 'assert')
         return execAssertStep(step, vars, ctx);
     if (step.type === 'verify')
-        return await execVerifyStep(step, vars);
+        return await execVerifyStep(step, vars, ctx);
     // set / echo 从 runSteps 的内联块搬进执行器体系：它们不影响迭代、只产出 StepResult。
     // 搬过来的直接收益是 `capture:` 自然生效（此前它们从不调 bindCapture —— 静默失效）。
     if (step.type === 'set')
@@ -340,6 +341,20 @@ function collectDeclaredArtifacts(def) {
 export async function* runWorkflow(def, inputs, ctx) {
     const vars = new VarStack();
     vars.setGlobal('inputs', inputs);
+    // 让 fileExists / readJson（done_when、when、over 都靠它们）与写入侧锚同一个目录。
+    // 传函数而非当前值：worktree 是运行途中才可能进入的，锚点必须每次求值时重算。
+    vars.resolveCwd = () => effectiveWorkflowCwd(ctx);
+    // Phase 3：session 即任务实例。优先用宿主显式提供的 sessionId（TUI 当前会话 /
+    // -p 的 --session）；缺失或为缺省 'default' 时，由工作流引擎自动命名一个唯一
+    // session（generateDefaultSessionId，见 taskIdentity.ts）——保证每次工作流运行都
+    // 有独立目录，多 session 并行互不覆盖；宿主显式指定时仍可复用/续跑该 session。
+    // 注入全局变量 `session`（sanitize 后的目录安全名），供 yaml 产物路径用
+    // ${session} 占位符（如 out/research/${session}/01-goal.md）。
+    const explicitSessionId = ctx.runtimeContext?.sessionId;
+    const sessionId = explicitSessionId && explicitSessionId !== DEFAULT_SESSION_ID
+        ? explicitSessionId
+        : generateDefaultSessionId();
+    vars.setGlobal('session', sanitizeWorkflowDirName(sessionId));
     // onError:'recover' 用：把工作流总目标（description）透传给恢复 agent，
     // 让它知道「这条工作流到底想干什么」。已有 goal 则不覆盖。
     const runCtx = { ...ctx, goal: ctx.goal ?? def.description };
@@ -353,13 +368,17 @@ export async function* runWorkflow(def, inputs, ctx) {
     runCtx.maxTurnsRetryDelayMs = def.self_heal?.max_turns_retry_delay_ms;
     // 声明产物清单：state.init 用于 new-task 清理/completed 报产物；
     // 挂到 runCtx 供 tool 步覆盖判定（声明产物自动 pre-Read 解 Write 守卫）。
-    const declaredArtifacts = collectDeclaredArtifacts(def);
+    // Phase 3：产物路径可能含 ${session} 占位符，收集后按 vars 展开为实际路径
+    //（new-task 清理 / completed 报告都以展开后的真实路径为准）。
+    const declaredArtifacts = collectDeclaredArtifacts(def)
+        .map((a) => interpolate(a, vars))
+        .filter((a) => a.length > 0);
     runCtx.declaredArtifacts = declaredArtifacts;
     // 任务身份语义仲裁器（hash 不等 + 旧任务未完成时的二审，见 taskIdentity.ts）：
     // 短语快路径 → LLM 单轮仲裁 → AskUserQuestion → 兜底 new-task。
     // init 非 generator，仲裁过程的人话记录收进 notes，init 返回后统一 yield。
     const arbitrationNotes = [];
-    const state = new WorkflowState(getWorkingDir(), def.name);
+    const state = new WorkflowState(getWorkingDir(), def.name, sessionId);
     const resume = await state.init(def.name, inputs, def.steps, def.self_heal?.backoff, declaredArtifacts, buildTaskArbitrator({
         provider: runCtx.provider,
         chat: runCtx.chat,
@@ -396,9 +415,16 @@ export async function* runWorkflow(def, inputs, ctx) {
             message: '♻ 工作流定义已变更（步骤结构与旧断点不再匹配），旧执行现场已作废，本次从头开始执行。',
         };
     }
-    // fresh/new-task 启动清理可见化：全新任务开始前已删掉的残留产物（上次任务
+    // fresh/new-task 启动清理可见化：全新任务开始前清理的残留产物（上次任务
     // 的声明产物 + /new 后无主孤儿）。用户约定：全新 plan 一律从干净状态开始；
     // 删除范围仅限本工作流声明的产物，同任务 resume 不清理。
+    // 清理一律先归档到 .trash 回收目录再删残留：仲裁误判 new-task 时成果可找回。
+    if (resume.archivedTo) {
+        yield {
+            type: 'warning',
+            message: `全新任务：上次残留的旧产物已归档到 ${resume.archivedTo}/（确认不需要后可删除该目录），从干净状态开始。`,
+        };
+    }
     if (resume.cleanedArtifacts?.length) {
         yield {
             type: 'warning',

package/plugins/workflow-runner/src/runner.ts

@@ -28,7 +28,8 @@ import { dlog, executeTool, getWorkingDir, type LoopEvent } from '../../../src/p
 import { isMaxTurnsCutoff, truncate } from './agentCommon.js';
 import { evalExpr, interpolate, interpolateDeep, interpolateTyped } from './expressions.js';
 import { runRecovery } from './recovery.js';
-import { buildTaskArbitrator, isContinuationPhrase } from './taskIdentity.js';
+import { effectiveWorkflowCwd } from './toolRuntime.js';
+import { buildTaskArbitrator, DEFAULT_SESSION_ID, generateDefaultSessionId, isContinuationPhrase, sanitizeWorkflowDirName } from './taskIdentity.js';
 import { execAgentStep } from './stepExecutors/agent.js';
 import { execAssertStep } from './stepExecutors/assert.js';
 import { execVerifyStep } from './stepExecutors/verify.js';
@@ -206,7 +207,7 @@ async function* dispatchActionStep(
   ctx: RunContext,
 ): AsyncGenerator<LoopEvent, StepResult, void> {
   if (step.type === 'assert') return execAssertStep(step, vars, ctx);
-  if (step.type === 'verify') return await execVerifyStep(step, vars);
+  if (step.type === 'verify') return await execVerifyStep(step, vars, ctx);
   // set / echo 从 runSteps 的内联块搬进执行器体系：它们不影响迭代、只产出 StepResult。
   // 搬过来的直接收益是 `capture:` 自然生效（此前它们从不调 bindCapture —— 静默失效）。
   if (step.type === 'set') return yield* execSetStep(step, vars);
@@ -395,6 +396,22 @@ export async function* runWorkflow(
 ): AsyncGenerator<WorkflowEvent | LoopEvent, void, void> {
   const vars = new VarStack();
   vars.setGlobal('inputs', inputs);
+  // 让 fileExists / readJson（done_when、when、over 都靠它们）与写入侧锚同一个目录。
+  // 传函数而非当前值：worktree 是运行途中才可能进入的，锚点必须每次求值时重算。
+  vars.resolveCwd = () => effectiveWorkflowCwd(ctx);
+
+  // Phase 3：session 即任务实例。优先用宿主显式提供的 sessionId（TUI 当前会话 /
+  // -p 的 --session）；缺失或为缺省 'default' 时，由工作流引擎自动命名一个唯一
+  // session（generateDefaultSessionId，见 taskIdentity.ts）——保证每次工作流运行都
+  // 有独立目录，多 session 并行互不覆盖；宿主显式指定时仍可复用/续跑该 session。
+  // 注入全局变量 `session`（sanitize 后的目录安全名），供 yaml 产物路径用
+  // ${session} 占位符（如 out/research/${session}/01-goal.md）。
+  const explicitSessionId = ctx.runtimeContext?.sessionId;
+  const sessionId =
+    explicitSessionId && explicitSessionId !== DEFAULT_SESSION_ID
+      ? explicitSessionId
+      : generateDefaultSessionId();
+  vars.setGlobal('session', sanitizeWorkflowDirName(sessionId));
 
   // onError:'recover' 用：把工作流总目标（description）透传给恢复 agent，
   // 让它知道「这条工作流到底想干什么」。已有 goal 则不覆盖。
@@ -412,14 +429,18 @@ export async function* runWorkflow(
 
   // 声明产物清单：state.init 用于 new-task 清理/completed 报产物；
   // 挂到 runCtx 供 tool 步覆盖判定（声明产物自动 pre-Read 解 Write 守卫）。
-  const declaredArtifacts = collectDeclaredArtifacts(def);
+  // Phase 3：产物路径可能含 ${session} 占位符，收集后按 vars 展开为实际路径
+  //（new-task 清理 / completed 报告都以展开后的真实路径为准）。
+  const declaredArtifacts = collectDeclaredArtifacts(def)
+    .map((a) => interpolate(a, vars))
+    .filter((a) => a.length > 0);
   runCtx.declaredArtifacts = declaredArtifacts;
 
   // 任务身份语义仲裁器（hash 不等 + 旧任务未完成时的二审，见 taskIdentity.ts）：
   // 短语快路径 → LLM 单轮仲裁 → AskUserQuestion → 兜底 new-task。
   // init 非 generator，仲裁过程的人话记录收进 notes，init 返回后统一 yield。
   const arbitrationNotes: string[] = [];
-  const state = new WorkflowState(getWorkingDir(), def.name);
+  const state = new WorkflowState(getWorkingDir(), def.name, sessionId);
   const resume = await state.init(
     def.name,
     inputs,
@@ -469,9 +490,16 @@ export async function* runWorkflow(
     };
   }
 
-  // fresh/new-task 启动清理可见化：全新任务开始前已删掉的残留产物（上次任务
+  // fresh/new-task 启动清理可见化：全新任务开始前清理的残留产物（上次任务
   // 的声明产物 + /new 后无主孤儿）。用户约定：全新 plan 一律从干净状态开始；
   // 删除范围仅限本工作流声明的产物，同任务 resume 不清理。
+  // 清理一律先归档到 .trash 回收目录再删残留：仲裁误判 new-task 时成果可找回。
+  if (resume.archivedTo) {
+    yield {
+      type: 'warning',
+      message: `全新任务：上次残留的旧产物已归档到 ${resume.archivedTo}/（确认不需要后可删除该目录），从干净状态开始。`,
+    };
+  }
   if (resume.cleanedArtifacts?.length) {
     yield {
       type: 'warning',

package/plugins/workflow-runner/src/stepExecutors/assert.js

@@ -8,6 +8,7 @@
  *  让后续 LLM 步骤能看到验证通过的信息（如"文件已存在""变量值符合预期"等）。
  * ============================================================
  */
+import { randomUUID } from 'node:crypto';
 import { evalExpr, interpolate } from '../expressions.js';
 export function execAssertStep(step, vars, ctx) {
     if (typeof step.condition !== 'string') {
@@ -34,7 +35,7 @@ export function execAssertStep(step, vars, ctx) {
             role: 'assistant',
             content: `[workflow:${step.id}] ✅ 断言通过：${step.condition}`,
             timestamp: Date.now(),
-            id: crypto.randomUUID(),
+            id: randomUUID(),
         });
     }
     return { raw: { ok: true }, preview: 'assert passed' };

package/plugins/workflow-runner/src/stepExecutors/assert.ts

@@ -9,6 +9,8 @@
  * ============================================================
  */
 
+import { randomUUID } from 'node:crypto';
+
 import { evalExpr, interpolate } from '../expressions.js';
 import type { RunContext, StepDef, StepResult, VarStack } from '../types.js';
 
@@ -42,7 +44,7 @@ export function execAssertStep(
       role: 'assistant',
       content: `[workflow:${step.id}] ✅ 断言通过：${step.condition}`,
       timestamp: Date.now(),
-      id: crypto.randomUUID(),
+      id: randomUUID(),
     });
   }