minimal-agent 0.12.0 → 0.13.0

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

@@ -1,6 +1,6 @@
-import { createHash } from 'node:crypto';
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { createHash, randomBytes, randomUUID } from 'node:crypto';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { isAbsolute, join, resolve } from 'node:path';
 
 import {
   chat as sdkChat,
@@ -12,28 +12,96 @@ import { extractJsonPayload } from './jsonPayload.js';
 import type { RunContext } from './types.js';
 
 // ============================================================
-//  工作流状态目录布局（E6 修复：按 workflow 名隔离）
+//  工作流状态目录布局（Phase 1 + 2 + 3 升级）
 // ------------------------------------------------------------
-//  <cwd>/.minimal-agent-workflow/<name>/      ← 每个工作流独立状态
-//  <cwd>/.minimal-agent-workflow/<name>.done/ ← 成功归档
-//  曾经一个 cwd 单例目录：A（如 /plan）未完成时跑不同名工作流 B，
-//  init 的 new-task 路径会清掉 A 的声明产物 + 整个状态目录，A 永久失去
-//  resume 能力——与「不同任务中间文件互不干扰」需求直接冲突。
-//  按名隔离后跨工作流互不可见，互踩从结构上消失。
-//  /new 的前缀清理（.minimal-agent*）作用于父目录，行为不变。
+//  状态根目录优先级：
+//    1. 环境变量 MINIMAL_AGENT_WORKFLOW_STATE_DIR（全局统一目录）
+//    2. <cwd>/.minimal-agent-workflow/（默认，与历史行为一致）
+//
+//  目录结构（三级：工作流名 / session 实例 / taskId 记录）：
+//    <stateRoot>/<workflowName>/<sessionId>/       ← 活动任务实例（session 即任务实例）
+//    <stateRoot>/<workflowName>/<sessionId>.done/  ← 成功完成的实例归档
+//    <stateRoot>/<workflowName>/<sessionId>.trash/ ← 清理回收（A4 归档）
+//
+//  Phase 3（session 化）：实例目录名 = sessionId（一个 session 同时只跑一个
+//  同名工作流，session 即天然的任务实例划分单元）。taskId（goal 内容 hash）
+//  降级为 current.json 里的【记录字段】——用于同 session 内识别「换主题 →
+//  new-task 归档重建 / 同主题 → resume/completed」。不同 session 完全隔离，
+//  同主题也可并行互不干扰。
+//
+//  演进历史：
+//    - 最初：<cwd>/.minimal-agent-workflow/ 单例（所有工作流共用）
+//    - E6：按 workflow 名隔离，<cwd>/.minimal-agent-workflow/<name>/
+//    - Phase 1：状态根目录可配置（环境变量指定全局位置，解决 cwd 切换找不到）
+//    - Phase 2：新增 taskId 实例层，同名 workflow 多任务并存（根治新任务清掉旧状态）
+//    - Phase 3：实例目录名改为 sessionId，taskId 降级为记录字段（多 session 真正并行）
 // ============================================================
 
-/** 工作流状态目录的父目录名（/new 按 .minimal-agent 前缀整体清理）。 */
+/** 工作流状态目录的父目录名（默认落在 cwd 下时使用）。 */
 export const WF_STATE_PARENT = '.minimal-agent-workflow';
 
-/** 把 workflow 名清洗成安全的目录名（保留字母数字._-，其余替换为 -）。 */
+/** 全局统一状态目录的环境变量名。 */
+export const WF_STATE_DIR_ENV = 'MINIMAL_AGENT_WORKFLOW_STATE_DIR';
+
+/** 缺省 sessionId（宿主未显式传 session 时的兜底判定值；真正落盘的 session 由 generateDefaultSessionId 自动命名）。 */
+export const DEFAULT_SESSION_ID = 'default';
+
+/**
+ * 工作流引擎的默认 session 自动命名：宿主未显式提供有意义 session（缺失或为
+ * DEFAULT_SESSION_ID）时，由引擎自行生成唯一可读的 session 名
+ * `YYYYMMDD-HHmmss-xxxxxx`（日期时间 + 6 位随机 hex）。
+ *
+ * 语义：每次工作流运行（CLI -p 默认 / TUI default 会话）都自动落到独立的
+ * `<out>/<workflow>/<session>/` 产物目录与 `<stateRoot>/<workflow>/<session>/`
+ * 状态目录——多 session 并行互不覆盖；时间前缀便于人识别与排序，随机后缀
+ * 防同一秒并行冲突。宿主显式传 `-s <id>`（非 default）时仍优先使用宿主 id。
+ */
+export function generateDefaultSessionId(now = new Date()): string {
+  const pad = (n: number, w = 2): string => String(n).padStart(w, '0');
+  const date = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}`;
+  const time = `${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+  const rand = randomBytes(3).toString('hex');
+  return `${date}-${time}-${rand}`;
+}
+
+/**
+ * 解析状态根目录（绝对路径）。
+ * 优先级：环境变量 MINIMAL_AGENT_WORKFLOW_STATE_DIR > cwd 下默认目录。
+ * 环境变量允许相对路径——基于 process.cwd() 展开（用户可能写 `.wflow` 这类相对值）。
+ * 传入 workingDir 是为了 cwd 默认模式的相对路径基准。
+ */
+export function resolveStateRoot(workingDir: string): string {
+  const envDir = process.env[WF_STATE_DIR_ENV];
+  if (envDir && envDir.trim()) {
+    const p = envDir.trim();
+    return isAbsolute(p) ? p : resolve(p);
+  }
+  return join(workingDir, WF_STATE_PARENT);
+}
+
+/** 把 workflow 名 / sessionId 清洗成安全的目录名（保留字母数字._-，其余替换为 -）。 */
 export function sanitizeWorkflowDirName(name: string): string {
   return name.replace(/[^\w.-]/g, '-');
 }
 
-/** 某 workflow 的状态目录绝对路径。workflowState / taskIdentity 共用唯一权威实现。 */
+/**
+ * 某 workflow 的状态目录绝对路径（workflow 级目录，下含多个 session 实例）。
+ * workflowState / taskIdentity 共用唯一权威实现。
+ */
 export function workflowStateDir(workingDir: string, workflowName: string): string {
-  return join(workingDir, WF_STATE_PARENT, sanitizeWorkflowDirName(workflowName));
+  return join(resolveStateRoot(workingDir), sanitizeWorkflowDirName(workflowName));
+}
+
+/**
+ * 具体任务实例（= session）的状态目录。
+ * 成功后改名为 <sessionId>.done/；清理归档目录为 <sessionId>.trash/。
+ */
+export function taskInstanceDir(
+  workingDir: string,
+  workflowName: string,
+  sessionId: string,
+): string {
+  return join(workflowStateDir(workingDir, workflowName), sanitizeWorkflowDirName(sessionId));
 }
 
 /**
@@ -64,11 +132,19 @@ export interface TaskIdentityResult {
  *   - 去除所有标点符号（保留中文、英文、数字、空格）
  *   - 去除多余空格（连续空格→单空格，首尾 trim）
  *   - 截断到 200 字符（防止超长输入导致不必要的差异）
+ *
+ * 参数：
+ *   - workingDir：不传只返回 hash（纯计算，不读盘）。
+ *   - sessionId：Phase 3 后传入——实例查找限定到「当前 session」的实例目录
+ *     （<wfDir>/<sessionId>/ 与 <sessionId>.done/），读其 current.json 的 taskId
+ *     记录与本次 hash 比较。缺省时退化为旧行为（扫 wfDir 下所有 taskId 实例），
+ *     兼容历史调用与测试。
  */
 export function computeTaskId(
   workflowName: string,
   inputs: Record<string, unknown>,
   workingDir?: string,
+  sessionId?: string,
 ): TaskIdentityResult {
   // 1. 提取 goal 文本（与 buildGoalAnchor 同策略）
   const rawGoal = extractGoal(inputs);
@@ -91,9 +167,25 @@ export function computeTaskId(
     };
   }
 
-  // 5. 尝试读取旧状态文件（按 workflow 名隔离的状态目录）
-  const stateFilePath = join(workflowStateDir(workingDir, workflowName), 'current.json');
+  // 5. 找当前任务对应的实例目录，读其 current.json 记录与本次 hash 比较
+  //    （Phase 3：session 语义——只查当前 session 的实例；taskId 是记录字段）
+  const wfDir = workflowStateDir(workingDir, workflowName);
+  const candidateDirs = findTaskInstanceDirs(wfDir, contentHash, sessionId);
 
+  if (candidateDirs.length === 0) {
+    // 无精确匹配。但若 wfDir 下存在其他任务实例（不同 goal / 已归档），
+    // 语义仍是「新任务 + 旧任务在场」——返回 hash_diff 而非 no_previous，
+    // 让 workflowState.init 能触发仲裁/清理旧产物（旧布局靠读 wfDir/current.json
+    // 天然得到这个信号，新布局必须显式扫描）。
+    return {
+      hash: contentHash,
+      isSameTask: false,
+      reason: hasAnyTaskInstanceInDir(wfDir, sessionId) ? 'hash_diff' : 'no_previous',
+    };
+  }
+
+  // 取第一个匹配的（hash 一样就是同一任务，不应有多个；有多个也只取第一个）
+  const stateFilePath = join(candidateDirs[0], 'current.json');
   if (!existsSync(stateFilePath)) {
     return {
       hash: contentHash,
@@ -103,14 +195,14 @@ export function computeTaskId(
   }
 
   try {
-    const stateContent = readFileSync(stateFilePath, 'utf-8');
+    const stateContent = readFileSync(stateFilePath, 'utf8');
     const prevState = JSON.parse(stateContent) as {
       taskId?: string;
       name?: string;
       startedAt?: string;
     };
 
-    // a. 不同 workflow 名 → 不同任务
+    // a. 不同 workflow 名 → 不同任务（理论上不会发生，因为已经按目录隔离了，防御性检查）
     if (prevState.name && prevState.name !== workflowName) {
       return {
         hash: contentHash,
@@ -144,6 +236,95 @@ export function computeTaskId(
   }
 }
 
+/**
+ * 在 workflow 级目录下，找到当前任务对应的实例目录。
+ * 支持两种布局：
+ *   - 新布局（Phase 3，传 sessionId）：<wfDir>/<sessionId>/current.json（活动）
+ *     与 <wfDir>/<sessionId>.done/current.json（已完成）
+ *   - 旧布局（Phase 2，不传 sessionId）：<wfDir>/<taskId>/current.json
+ *     与 <wfDir>/<taskId>.done/current.json
+ *   - 旧布局兼容（无 session 层）：<wfDir>/current.json —— 把整个 wfDir 当成一个实例
+ * 返回绝对路径数组。
+ */
+function findTaskInstanceDirs(
+  wfDir: string,
+  taskId: string,
+  sessionId?: string,
+): string[] {
+  const results: string[] = [];
+
+  if (sessionId) {
+    // Phase 3：session 语义 —— 只找当前 session 的实例（taskId 是记录字段，目录名是 sessionId）
+    const activeDir = join(wfDir, sanitizeWorkflowDirName(sessionId));
+    const doneDir = join(wfDir, `${sanitizeWorkflowDirName(sessionId)}.done`);
+    if (existsSync(activeDir)) results.push(activeDir);
+    if (existsSync(doneDir)) results.push(doneDir);
+  } else {
+    // Phase 2 旧行为：<wfDir>/<taskId>/ 和 <wfDir>/<taskId>.done/
+    const activeDir = join(wfDir, taskId);
+    const doneDir = join(wfDir, `${taskId}.done`);
+    if (existsSync(activeDir)) results.push(activeDir);
+    if (existsSync(doneDir)) results.push(doneDir);
+  }
+
+  if (results.length > 0) return results;
+
+  // 旧布局兼容：wfDir 本身就是实例目录（current.json 直接在 wfDir 下）
+  // 检测方法：wfDir/current.json 存在且 wfDir 下没有子目录是 taskId 格式
+  if (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) {
+        results.push(wfDir);
+      }
+    } catch {
+      // 读不到就当旧布局
+      results.push(wfDir);
+    }
+  }
+
+  return results;
+}
+
+/**
+ * 检查 wfDir 下是否存在任何任务实例（活动态 / .done 归档态 / 旧布局 current.json）。
+ * 不含 .trash 回收目录。用于 computeTaskId 在无精确匹配时区分
+ * hash_diff（有其他旧任务）与 no_previous（从未跑过）。
+ * 传 sessionId 时只统计当前 session 的实例（Phase 3）。
+ */
+function hasAnyTaskInstanceInDir(wfDir: string, sessionId?: string): boolean {
+  if (!existsSync(wfDir)) return false;
+  try {
+    if (sessionId) {
+      // Phase 3：只看当前 session 的实例
+      const active = join(wfDir, sanitizeWorkflowDirName(sessionId));
+      const done = join(wfDir, `${sanitizeWorkflowDirName(sessionId)}.done`);
+      if (existsSync(active)) return true;
+      if (existsSync(done)) return true;
+      // 旧布局：wfDir 本身就是实例目录
+      if (existsSync(join(wfDir, 'current.json'))) return true;
+      if (existsSync(join(wfDir + '.done', 'current.json'))) return true;
+      return false;
+    }
+    const entries = readdirSync(wfDir, { withFileTypes: true });
+    for (const e of entries) {
+      if (!e.isDirectory()) continue;
+      if (/^[0-9a-f]{16}$/.test(e.name)) return true; // 活动实例
+      if (/^[0-9a-f]{16}\.done$/.test(e.name)) return true; // 归档实例
+    }
+    // 旧布局：wfDir 本身就是实例目录
+    if (existsSync(join(wfDir, 'current.json'))) return true;
+    if (existsSync(join(wfDir + '.done', 'current.json'))) return true;
+    return false;
+  } catch {
+    return false;
+  }
+}
+
 /**
  * 从 inputs 中提取 goal 文本
  *
@@ -326,7 +507,7 @@ async function llmArbitrate(
   for await (const ev of chatFn({
     provider: deps.provider,
     messages: [
-      { role: 'user', content: prompt, timestamp: Date.now(), id: crypto.randomUUID() },
+      { role: 'user', content: prompt, timestamp: Date.now(), id: randomUUID() },
     ],
     tools: [],
     signal: deps.signal,

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

@@ -12,6 +12,7 @@
  *  src/types.ts 的 LoopEvent union **不**包含 workflow_*，框架零插件耦合。
  * ============================================================
  */
+import { resolve, sep } from 'node:path';
 // ---------------- 2. 变量栈（loop scope 用） ----------------
 /**
  * 简单的多帧变量栈：
@@ -20,9 +21,21 @@
  *   - 退出 loop 时 pop()
  *
  * get(key) 从栈顶往下找第一个匹配的 frame，类似 JS 的 lexical scope。
+ *
+ * ════════════════ 原型污染防护（v2） ════════════════
+ *  三层防线，任何一层破了都还有下一层兜底：
+ *  ① 所有 frame 对象用 `Object.create(null)` 创建 → 根本没有原型访问器，
+ *     obj["__proto__"] = {...} 不会触发 setter（因为 Object.create(null)
+ *     的 [[Prototype]] 是 null，没有 Object.prototype.__proto__ 那个 getter/
+ *     setter），只会写成 own property。
+ *  ② set* 写入口统一过滤 DANGEROUS_KEYS（`__proto__/constructor/prototype`）
+ *     → 即使将来有人改回普通 {} 对象，写操作也到不了原型。
+ *  ③ 读侧（expressions 点路径访问）另有 S1 黑名防护（parsePrimary L451），
+ *     即使值真写进去了也读不出来。
+ * ════════════════════════════════════════════════════
  */
 export class VarStack {
-    frames = [{}];
+    frames = [Object.create(null)];
     /**
      * 哪些帧是「循环迭代帧」—— 只为装 `as` / `as_idx` 这类**每轮重置**的迭代变量而生。
      *
@@ -37,12 +50,24 @@ export class VarStack {
      * 而不是「它只在这一轮迭代里活着」。
      */
     iterationFrames = new Set();
+    /**
+     * 本次运行「当前有效工作目录」的解析器，供 fileExists / readJson 这类**读磁盘**的
+     * 内置函数取锚点用。不是 yaml 变量（不进 frames，`${cwd}` 取不到它）。
+     *
+     * ⚠️ 存的是**函数**不是字符串：worktree 是运行途中才进入的（模型调 EnterWorktree），
+     * 创建 VarStack 时固定成字符串的话，之后所有 done_when 仍会锚在旧目录上。
+     * 未设置时由调用方回落 getWorkingDir()。
+     */
+    resolveCwd;
     /**
      * 写一个**作者命名**的变量（capture / set 步 / 引擎内部状态）。
      *
      * 穿透所有迭代帧，落到最近的非迭代帧上 —— 这样它在循环结束后依然存在。
+     * 危险键（__proto__/constructor/prototype）直接忽略（防线②）。
      */
     set(key, val) {
+        if (DANGEROUS_KEYS.has(key))
+            return;
         for (let i = this.frames.length - 1; i >= 0; i--) {
             if (!this.iterationFrames.has(i)) {
                 this.frames[i][key] = val;
@@ -51,15 +76,24 @@ export class VarStack {
         }
         this.frames[0][key] = val;
     }
-    /** 写一个**迭代变量**（`as` / `as_idx`）：落在当前迭代帧，随 pop 一起消失。 */
+    /** 写一个**迭代变量**（`as` / `as_idx`）：落在当前迭代帧，随 pop 一起消失。
+     *  危险键直接忽略（防线②）。 */
     setIteration(key, val) {
+        if (DANGEROUS_KEYS.has(key))
+            return;
         this.frames[this.frames.length - 1][key] = val;
     }
-    /** 写到栈底（root frame），用于 inputs / 全局常量 */
+    /** 写到栈底（root frame），用于 inputs / 全局常量。危险键直接忽略（防线②）。 */
     setGlobal(key, val) {
+        if (DANGEROUS_KEYS.has(key))
+            return;
         this.frames[0][key] = val;
     }
     get(key) {
+        // 读侧也过危险键：防止 Object.create(null) 上若后续被别的代码写入了 own property
+        // 形式的 __proto__，读出来再被其他地方当对象 key 造成二次污染。
+        if (DANGEROUS_KEYS.has(key))
+            return undefined;
         for (let i = this.frames.length - 1; i >= 0; i--) {
             if (key in this.frames[i])
                 return this.frames[i][key];
@@ -67,6 +101,8 @@ export class VarStack {
         return undefined;
     }
     has(key) {
+        if (DANGEROUS_KEYS.has(key))
+            return false;
         for (let i = this.frames.length - 1; i >= 0; i--) {
             if (key in this.frames[i])
                 return true;
@@ -74,11 +110,11 @@ export class VarStack {
         return false;
     }
     push() {
-        this.frames.push({});
+        this.frames.push(Object.create(null));
     }
     /** 压一个迭代帧：只有 `setIteration` 写进来的东西会随 `pop` 消失。 */
     pushIteration() {
-        this.frames.push({});
+        this.frames.push(Object.create(null));
         this.iterationFrames.add(this.frames.length - 1);
     }
     pop() {
@@ -87,9 +123,18 @@ export class VarStack {
             this.frames.pop();
         }
     }
-    /** 合并所有帧为一个普通对象（外层覆盖内层），用于 vars 持久化与事件 */
+    /** 合并所有帧为一个普通对象（外层覆盖内层），用于 vars 持久化与事件。
+     *  危险键不进入快照（双重保险：帧是 Object.create(null)，读的时候也过不了 get）。*/
     snapshot() {
-        return Object.assign({}, ...this.frames);
+        const out = {};
+        for (const frame of this.frames) {
+            for (const k of Object.keys(frame)) {
+                if (DANGEROUS_KEYS.has(k))
+                    continue;
+                out[k] = frame[k];
+            }
+        }
+        return out;
     }
 }
 /**
@@ -109,3 +154,64 @@ export function normalizeCapture(cap) {
         return { result: cap };
     return cap;
 }
+// ---------------- 6. 路径安全守卫（declaredArtifacts / 表达式层共用） ----------------
+/**
+ * 规范化 + cwd 范围校验的产物路径。
+ *
+ * 安全背景：declaredArtifacts 来自 YAML 定义，若作者写 "../../.ssh/id_rsa"，
+ * path.join(workingDir, p) 会跟随 ../ 跳出工作目录，new-task 清理时就可能
+ * 删掉工作目录外的文件（唯一能造成真实数据损失的入口）。
+ *
+ * 行为：
+ *   - 先用 resolve(workingDir, rawPath) 得到绝对路径（自动归一化 ../）
+ *   - 再检查它是否严格在 resolve(workingDir) 目录树之内
+ *   - 命中：返回【相对 workingDir 的规范化相对路径】（./ 前缀去除、\\→/），
+ *     保证后续 join(workingDir, result) 一定不会越界
+ *   - 越界/空串/解析失败：返回 null，调用方应跳过（fail-closed）
+ *
+ * 跨平台：win32 上 compare 前双方都 normalizeCase（lowercase），其他平台保持大小写敏感。
+ */
+export function safeArtifactPath(workingDir, rawPath) {
+    if (!rawPath || typeof rawPath !== 'string')
+        return null;
+    const base = resolve(workingDir);
+    // 必须加路径分隔符作为前缀匹配边界：防止 base=/repo 匹配到 /repo-hack/evil
+    const baseWithSep = base.endsWith(sep) ? base : base + sep;
+    let abs;
+    try {
+        abs = resolve(workingDir, rawPath);
+    }
+    catch {
+        return null;
+    }
+    const sameCase = (p) => process.platform === 'win32' ? p.toLowerCase() : p;
+    const nAbs = sameCase(abs);
+    const nBase = sameCase(base);
+    const nBaseSep = sameCase(baseWithSep);
+    // 恰好等于 base 本身（极端的 rawPath='.' 情形）也视为合法，但 caller 一般
+    // 用的是具体文件；这里允许不报错。
+    if (nAbs !== nBase && !nAbs.startsWith(nBaseSep))
+        return null;
+    // 导出【相对 workingDir 的相对路径】（去掉 base 前缀）
+    const rel = abs.slice(base.length).replace(/^[/\\]/, '');
+    return rel.length === 0 ? '.' : rel;
+}
+/**
+ * 表达式/任意场景的通用「绝对路径是否在 cwd 内」判定。
+ *   - abs 必须是【已 resolve 后的绝对路径】
+ *   - 越界/空 → false
+ */
+export function isAbsWithinCwd(workingDir, abs) {
+    if (!abs)
+        return false;
+    const base = resolve(workingDir);
+    const baseWithSep = base.endsWith(sep) ? base : base + sep;
+    const sameCase = (p) => process.platform === 'win32' ? p.toLowerCase() : p;
+    const nAbs = sameCase(abs);
+    return nAbs === sameCase(base) || nAbs.startsWith(sameCase(baseWithSep));
+}
+/**
+ * 危险键黑名单：VarStack.set* / interpolateDeep 对象 key / 点路径访问统一过滤。
+ * 防止原型污染 / 构造函数逃逸。与 expressions.ts parsePrimary S1 白名单保持一致。
+ */
+export const DANGEROUS_KEYS = new Set(['__proto__', 'constructor', 'prototype']);

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

@@ -13,6 +13,8 @@
  * ============================================================
  */
 
+import { resolve, sep } from 'node:path';
+
 import type {
   ImageDetail,
   Message,
@@ -320,9 +322,21 @@ export interface WorkflowDef {
  *   - 退出 loop 时 pop()
  *
  * get(key) 从栈顶往下找第一个匹配的 frame，类似 JS 的 lexical scope。
+ *
+ * ════════════════ 原型污染防护（v2） ════════════════
+ *  三层防线，任何一层破了都还有下一层兜底：
+ *  ① 所有 frame 对象用 `Object.create(null)` 创建 → 根本没有原型访问器，
+ *     obj["__proto__"] = {...} 不会触发 setter（因为 Object.create(null)
+ *     的 [[Prototype]] 是 null，没有 Object.prototype.__proto__ 那个 getter/
+ *     setter），只会写成 own property。
+ *  ② set* 写入口统一过滤 DANGEROUS_KEYS（`__proto__/constructor/prototype`）
+ *     → 即使将来有人改回普通 {} 对象，写操作也到不了原型。
+ *  ③ 读侧（expressions 点路径访问）另有 S1 黑名防护（parsePrimary L451），
+ *     即使值真写进去了也读不出来。
+ * ════════════════════════════════════════════════════
  */
 export class VarStack {
-  private frames: Record<string, unknown>[] = [{}];
+  private frames: Record<string, unknown>[] = [Object.create(null)];
   /**
    * 哪些帧是「循环迭代帧」—— 只为装 `as` / `as_idx` 这类**每轮重置**的迭代变量而生。
    *
@@ -338,12 +352,24 @@ export class VarStack {
    */
   private iterationFrames = new Set<number>();
 
+  /**
+   * 本次运行「当前有效工作目录」的解析器，供 fileExists / readJson 这类**读磁盘**的
+   * 内置函数取锚点用。不是 yaml 变量（不进 frames，`${cwd}` 取不到它）。
+   *
+   * ⚠️ 存的是**函数**不是字符串：worktree 是运行途中才进入的（模型调 EnterWorktree），
+   * 创建 VarStack 时固定成字符串的话，之后所有 done_when 仍会锚在旧目录上。
+   * 未设置时由调用方回落 getWorkingDir()。
+   */
+  resolveCwd?: () => string;
+
   /**
    * 写一个**作者命名**的变量（capture / set 步 / 引擎内部状态）。
    *
    * 穿透所有迭代帧，落到最近的非迭代帧上 —— 这样它在循环结束后依然存在。
+   * 危险键（__proto__/constructor/prototype）直接忽略（防线②）。
    */
   set(key: string, val: unknown): void {
+    if (DANGEROUS_KEYS.has(key)) return;
     for (let i = this.frames.length - 1; i >= 0; i--) {
       if (!this.iterationFrames.has(i)) {
         this.frames[i][key] = val;
@@ -353,17 +379,23 @@ export class VarStack {
     this.frames[0][key] = val;
   }
 
-  /** 写一个**迭代变量**（`as` / `as_idx`）：落在当前迭代帧，随 pop 一起消失。 */
+  /** 写一个**迭代变量**（`as` / `as_idx`）：落在当前迭代帧，随 pop 一起消失。
+   *  危险键直接忽略（防线②）。 */
   setIteration(key: string, val: unknown): void {
+    if (DANGEROUS_KEYS.has(key)) return;
     this.frames[this.frames.length - 1][key] = val;
   }
 
-  /** 写到栈底（root frame），用于 inputs / 全局常量 */
+  /** 写到栈底（root frame），用于 inputs / 全局常量。危险键直接忽略（防线②）。 */
   setGlobal(key: string, val: unknown): void {
+    if (DANGEROUS_KEYS.has(key)) return;
     this.frames[0][key] = val;
   }
 
   get(key: string): unknown {
+    // 读侧也过危险键：防止 Object.create(null) 上若后续被别的代码写入了 own property
+    // 形式的 __proto__，读出来再被其他地方当对象 key 造成二次污染。
+    if (DANGEROUS_KEYS.has(key)) return undefined;
     for (let i = this.frames.length - 1; i >= 0; i--) {
       if (key in this.frames[i]) return this.frames[i][key];
     }
@@ -371,6 +403,7 @@ export class VarStack {
   }
 
   has(key: string): boolean {
+    if (DANGEROUS_KEYS.has(key)) return false;
     for (let i = this.frames.length - 1; i >= 0; i--) {
       if (key in this.frames[i]) return true;
     }
@@ -378,12 +411,12 @@ export class VarStack {
   }
 
   push(): void {
-    this.frames.push({});
+    this.frames.push(Object.create(null));
   }
 
   /** 压一个迭代帧：只有 `setIteration` 写进来的东西会随 `pop` 消失。 */
   pushIteration(): void {
-    this.frames.push({});
+    this.frames.push(Object.create(null));
     this.iterationFrames.add(this.frames.length - 1);
   }
 
@@ -394,9 +427,17 @@ export class VarStack {
     }
   }
 
-  /** 合并所有帧为一个普通对象（外层覆盖内层），用于 vars 持久化与事件 */
+  /** 合并所有帧为一个普通对象（外层覆盖内层），用于 vars 持久化与事件。
+   *  危险键不进入快照（双重保险：帧是 Object.create(null)，读的时候也过不了 get）。*/
   snapshot(): Record<string, unknown> {
-    return Object.assign({}, ...this.frames);
+    const out: Record<string, unknown> = {};
+    for (const frame of this.frames) {
+      for (const k of Object.keys(frame)) {
+        if (DANGEROUS_KEYS.has(k)) continue;
+        out[k] = frame[k];
+      }
+    }
+    return out;
   }
 }
 
@@ -600,3 +641,66 @@ export type WorkflowEvent =
     }
   | { type: 'workflow_step_skipped'; id: string; reason: string }
   | { type: 'workflow_done'; name: string; vars: Record<string, unknown> };
+
+// ---------------- 6. 路径安全守卫（declaredArtifacts / 表达式层共用） ----------------
+
+/**
+ * 规范化 + cwd 范围校验的产物路径。
+ *
+ * 安全背景：declaredArtifacts 来自 YAML 定义，若作者写 "../../.ssh/id_rsa"，
+ * path.join(workingDir, p) 会跟随 ../ 跳出工作目录，new-task 清理时就可能
+ * 删掉工作目录外的文件（唯一能造成真实数据损失的入口）。
+ *
+ * 行为：
+ *   - 先用 resolve(workingDir, rawPath) 得到绝对路径（自动归一化 ../）
+ *   - 再检查它是否严格在 resolve(workingDir) 目录树之内
+ *   - 命中：返回【相对 workingDir 的规范化相对路径】（./ 前缀去除、\\→/），
+ *     保证后续 join(workingDir, result) 一定不会越界
+ *   - 越界/空串/解析失败：返回 null，调用方应跳过（fail-closed）
+ *
+ * 跨平台：win32 上 compare 前双方都 normalizeCase（lowercase），其他平台保持大小写敏感。
+ */
+export function safeArtifactPath(workingDir: string, rawPath: string): string | null {
+  if (!rawPath || typeof rawPath !== 'string') return null;
+  const base = resolve(workingDir);
+  // 必须加路径分隔符作为前缀匹配边界：防止 base=/repo 匹配到 /repo-hack/evil
+  const baseWithSep = base.endsWith(sep) ? base : base + sep;
+  let abs: string;
+  try {
+    abs = resolve(workingDir, rawPath);
+  } catch {
+    return null;
+  }
+  const sameCase = (p: string): string =>
+    process.platform === 'win32' ? p.toLowerCase() : p;
+  const nAbs = sameCase(abs);
+  const nBase = sameCase(base);
+  const nBaseSep = sameCase(baseWithSep);
+  // 恰好等于 base 本身（极端的 rawPath='.' 情形）也视为合法，但 caller 一般
+  // 用的是具体文件；这里允许不报错。
+  if (nAbs !== nBase && !nAbs.startsWith(nBaseSep)) return null;
+  // 导出【相对 workingDir 的相对路径】（去掉 base 前缀）
+  const rel = abs.slice(base.length).replace(/^[/\\]/, '');
+  return rel.length === 0 ? '.' : rel;
+}
+
+/**
+ * 表达式/任意场景的通用「绝对路径是否在 cwd 内」判定。
+ *   - abs 必须是【已 resolve 后的绝对路径】
+ *   - 越界/空 → false
+ */
+export function isAbsWithinCwd(workingDir: string, abs: string): boolean {
+  if (!abs) return false;
+  const base = resolve(workingDir);
+  const baseWithSep = base.endsWith(sep) ? base : base + sep;
+  const sameCase = (p: string): string =>
+    process.platform === 'win32' ? p.toLowerCase() : p;
+  const nAbs = sameCase(abs);
+  return nAbs === sameCase(base) || nAbs.startsWith(sameCase(baseWithSep));
+}
+
+/**
+ * 危险键黑名单：VarStack.set* / interpolateDeep 对象 key / 点路径访问统一过滤。
+ * 防止原型污染 / 构造函数逃逸。与 expressions.ts parsePrimary S1 白名单保持一致。
+ */
+export const DANGEROUS_KEYS = new Set(['__proto__', 'constructor', 'prototype']);