minimal-agent 0.10.0 → 0.12.0

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

@@ -0,0 +1,622 @@
+/**
+ * ============================================================
+ *  plugins/workflow-runner/src/expressions.ts —— workflow 表达式引擎（mini）
+ * ------------------------------------------------------------
+ *  WHY 不直接 eval / Function？
+ *    Workflow 来源不可信（用户编辑器生成 / 别人贡献的 yaml），允许任意
+ *    JS 执行 = 任意远程代码执行。所以我们手写一个**只支持必要语法**的
+ *    递归下降解析器：常量、变量引用、点路径、字符串/数字字面量、数组、
+ *    比较、布尔运算、白名单内置函数。
+ *
+ *  支持的语法：
+ *    expr    := or
+ *    or      := and ( '||' and )*
+ *    and     := not ( '&&' not )*
+ *    not     := '!' not | comparison
+ *    comparison := additive ( ('==' | '!=' | '>=' | '<=' | '>' | '<') additive )?
+ *    additive := primary ( '+' primary )*        // number 相加 / 否则 stringify 后拼接
+ *    primary := number | string | array | call | path | interp | '(' expr ')'
+ *    array   := '[' expr (',' expr)* ']'
+ *    call    := IDENT '(' expr (',' expr)* ')'   // 白名单
+ *    path    := IDENT ('.' IDENT)*               // 变量 + 点路径
+ *    interp  := '${' EXPR '}'                     // 取 EXPR 的"值"（任意类型，不字符串化）
+ *    string  := "…" | '…'                         // 内嵌 ${EXPR} 走 template-literal 插值
+ *
+ *  白名单函数：fileExists / readJson / parseJson / asArray / length / lower / upper / includes /
+ *              startsWith / endsWith / match / split / extract / join / json
+ *
+ *  ★ P2 根治：表达式上下文（when/condition/over/assert/vote.input）直接 evalExpr，
+ *    不再"先 interpolate 再 eval"（旧双求值的 footgun 源头）。四种写法都 OK：
+ *      裸 ${x} == 'y'   → ${x} 取值后比较（修掉旧 footgun：旧实现把 ${x} 替成裸字面量被当变量名）
+ *      "a/${x}/b"       → 字符串字面量内插值拼路径（向后兼容旧 fileExists("…${x}…") 写法）
+ *      "a/" + x + "/b"  → + 拼接（新增）
+ *      x == 'y'         → 裸变量名（向后兼容）
+ *    安全性也更好：变量的字符串内容不再被当作表达式二次执行（旧实现若插值结果落在引号外会被 eval）。
+ *
+ *  插值函数 interpolate(${EXPR}) 仍用于**模板上下文**（prompt / args / file_path）——
+ *  把 EXPR 求值后 toString 替换；对象/数组用 JSON.stringify。interpolateDeep 递归处理对象/数组/字符串。
+ * ============================================================
+ */
+
+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';
+
+// ---------------- Tokenizer ----------------
+
+type Token =
+  | { kind: 'num'; value: number }
+  | { kind: 'str'; value: string }
+  | { kind: 'ident'; value: string }
+  | { kind: 'interp'; value: string }
+  | { kind: 'punct'; value: string };
+
+const PUNCT2 = new Set(['==', '!=', '>=', '<=', '&&', '||']);
+const PUNCT1 = new Set(['(', ')', '[', ']', ',', '.', '!', '>', '<', '+', '?', ':']);
+
+function tokenize(src: string): Token[] {
+  const out: Token[] = [];
+  let i = 0;
+  while (i < src.length) {
+    const c = src[i];
+    if (c === ' ' || c === '\t' || c === '\n' || c === '\r') {
+      i++;
+      continue;
+    }
+    // 独立 ${...} 取值 token。注意：字符串字面量内部的 ${} 不会到这里——
+    // 会被下面的字符串分支整体读进 str token，由 parsePrimary 在 eval 时插值。
+    if (c === '$' && src[i + 1] === '{') {
+      let depth = 1;
+      let j = i + 2;
+      while (j < src.length && depth > 0) {
+        if (src[j] === '{') depth++;
+        else if (src[j] === '}') depth--;
+        if (depth > 0) j++;
+      }
+      if (depth !== 0) throw new Error(`未闭合的 \${ 在表达式 "${src}"`);
+      out.push({ kind: 'interp', value: src.slice(i + 2, j) });
+      i = j + 1;
+      continue;
+    }
+    // 字符串
+    if (c === '"' || c === "'") {
+      const quote = c;
+      let s = '';
+      i++;
+      while (i < src.length && src[i] !== quote) {
+        if (src[i] === '\\' && i + 1 < src.length) {
+          const nx = src[i + 1];
+          s += nx === 'n' ? '\n' : nx === 't' ? '\t' : nx;
+          i += 2;
+        } else {
+          s += src[i++];
+        }
+      }
+      if (src[i] !== quote) throw new Error(`未闭合的字符串：${src}`);
+      i++;
+      out.push({ kind: 'str', value: s });
+      continue;
+    }
+    // 数字
+    if ((c >= '0' && c <= '9') || (c === '-' && src[i + 1] >= '0' && src[i + 1] <= '9')) {
+      let j = i;
+      if (src[j] === '-') j++;
+      while (j < src.length && ((src[j] >= '0' && src[j] <= '9') || src[j] === '.')) j++;
+      out.push({ kind: 'num', value: parseFloat(src.slice(i, j)) });
+      i = j;
+      continue;
+    }
+    // 双字符标点
+    const two = src.slice(i, i + 2);
+    if (PUNCT2.has(two)) {
+      out.push({ kind: 'punct', value: two });
+      i += 2;
+      continue;
+    }
+    // 单字符标点
+    if (PUNCT1.has(c)) {
+      out.push({ kind: 'punct', value: c });
+      i++;
+      continue;
+    }
+    // 标识符
+    if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c === '_') {
+      let j = i;
+      while (
+        j < src.length &&
+        ((src[j] >= 'a' && src[j] <= 'z') ||
+          (src[j] >= 'A' && src[j] <= 'Z') ||
+          (src[j] >= '0' && src[j] <= '9') ||
+          src[j] === '_')
+      ) {
+        j++;
+      }
+      out.push({ kind: 'ident', value: src.slice(i, j) });
+      i = j;
+      continue;
+    }
+    throw new Error(`非法字符 '${c}' 在表达式 "${src}"`);
+  }
+  return out;
+}
+
+// ---------------- Parser → AST → eval（一次性递归下降，零 AST 对象） ----------------
+
+interface Cursor {
+  toks: Token[];
+  pos: number;
+}
+
+function peek(c: Cursor): Token | null {
+  return c.pos < c.toks.length ? c.toks[c.pos] : null;
+}
+function eat(c: Cursor): Token {
+  return c.toks[c.pos++];
+}
+function isPunct(c: Cursor, v: string): boolean {
+  const t = peek(c);
+  return !!t && t.kind === 'punct' && t.value === v;
+}
+
+const BUILTINS: Record<string, (args: unknown[]) => unknown> = {
+  fileExists(args) {
+    const p = String(args[0] ?? '');
+    if (!p) return false;
+    const abs = isAbsolute(p) ? p : join(getWorkingDir(), p);
+    return existsSync(abs);
+  },
+  length(args) {
+    const v = args[0];
+    if (typeof v === 'string' || Array.isArray(v)) return v.length;
+    if (v && typeof v === 'object') return Object.keys(v).length;
+    return 0;
+  },
+  // 把可选 JSON 数组标准化为 for-each loop 可消费的数组。用于
+  // over: "${asArray(readJson('manifest.json', 'images'))}" 这类场景：
+  // 缺文件/缺字段/null 表示 0 轮；但对象/字符串等结构错误要响亮失败，
+  // 避免把坏 manifest 静默吞掉。
+  asArray(args) {
+    const v = args[0];
+    if (Array.isArray(v)) return v;
+    if (v === null || v === undefined) return [];
+    throw new Error(`asArray 期望数组/null/undefined，得到 ${Array.isArray(v) ? 'array' : typeof v}`);
+  },
+  lower(args) {
+    return String(args[0] ?? '').toLowerCase();
+  },
+  upper(args) {
+    return String(args[0] ?? '').toUpperCase();
+  },
+  includes(args) {
+    const haystack = String(args[0] ?? '');
+    const needle = String(args[1] ?? '');
+    return haystack.includes(needle);
+  },
+  startsWith(args) {
+    const s = String(args[0] ?? '');
+    const prefix = String(args[1] ?? '');
+    return s.startsWith(prefix);
+  },
+  endsWith(args) {
+    const s = String(args[0] ?? '');
+    const suffix = String(args[1] ?? '');
+    return s.endsWith(suffix);
+  },
+  match(args) {
+    const s = String(args[0] ?? '');
+    const pattern = String(args[1] ?? '');
+    try {
+      const re = new RegExp(pattern);
+      return re.test(s);
+    } catch {
+      return false; // 非法正则 → 不匹配
+    }
+  },
+  split(args) {
+    const s = String(args[0] ?? '');
+    const delim = args[1] !== undefined ? String(args[1]) : ',';
+    return s.split(delim);
+  },
+  // 全局正则提取：返回匹配数组。有捕获组取 group 1（典型：提取 <tag>(.*?)</tag> 内容），
+  // 否则取全匹配。flags 固定 gs（跨行 . 匹配）；非法正则返回 []（与 match 同哲学：不抛）。
+  // 动机：从 agent/llm 输出里确定性抽取协议标签（如 <learning>…</learning>），
+  // 替代「再开一个 LLM 步去提取」的幻觉/改写风险。
+  extract(args) {
+    const s = String(args[0] ?? '');
+    const pattern = String(args[1] ?? '');
+    if (!pattern) return [];
+    try {
+      const re = new RegExp(pattern, 'gs');
+      const out: string[] = [];
+      for (const m of s.matchAll(re)) {
+        out.push(m[1] !== undefined ? m[1] : m[0]);
+      }
+      return out;
+    } catch {
+      return [];
+    }
+  },
+  // 数组拼接成字符串；非数组按 stringify 兜底。与 extract 配对使用。
+  join(args) {
+    const v = args[0];
+    const sep = args[1] !== undefined ? String(args[1]) : ',';
+    if (Array.isArray(v)) return v.map((x) => stringify(x)).join(sep);
+    return stringify(v);
+  },
+  // JSON.stringify 安全嵌入：值含引号/换行时拼 JSON 文件不产坏文档
+  // （模板里写 "k": ${json(v)}，外层引号由 json() 自己生成）。
+  json(args) {
+    try {
+      return JSON.stringify(args[0] ?? null);
+    } catch {
+      return 'null';
+    }
+  },
+  // 读磁盘 JSON 文件并取值：path 相对 getWorkingDir()（绝对路径原样）；给了 key
+  // 则返回顶层 obj[key]，否则返回整值。缺文件 / 坏 JSON / 键不存在 → null
+  //（与 match/extract 同「不抛」哲学）。动机：让确定性脚本产出的 manifest
+  //（如 source_assets.json）直接驱动工作流 for-each / branch —— 填补「磁盘
+  // 结构化数据 → 控制流」的空白（与 fileExists 平级的基础能力）。
+  readJson(args) {
+    const p = String(args[0] ?? '');
+    if (!p) return null;
+    const abs = isAbsolute(p) ? p : join(getWorkingDir(), p);
+    try {
+      // 剥前导 BOM：某些工具/重定向写出的 JSON 带 BOM，JSON.parse 会因此抛错。
+      let raw = readFileSync(abs, 'utf8');
+      if (raw.charCodeAt(0) === 0xfeff) raw = raw.slice(1);
+      const val = JSON.parse(raw);
+      if (args.length >= 2) {
+        const key = String(args[1] ?? '');
+        return val != null && typeof val === 'object' ? (val[key] ?? null) : null;
+      }
+      return val;
+    } catch {
+      return null;
+    }
+  },
+  // 解析 JSON 字符串成值（与 readJson 平级，但源是**字符串**而非文件）：剥前导 BOM、
+  // trim、JSON.parse；非字符串 / 空 / 坏 JSON → null（同 match/extract/readJson「不抛」哲学）。
+  // 动机：把 WebBrowser eval / agent / 工具 capture 到的 JSON 文本变成数组/对象，
+  // 直接驱动 loop over / branch —— 填补「字符串结构化数据 → 控制流」的空白
+  //（配 asArray 用：over: "${asArray(parseJson(urls_json))}"）。
+  parseJson(args) {
+    const v = args[0];
+    if (typeof v !== 'string') return null;
+    let raw = v.charCodeAt(0) === 0xfeff ? v.slice(1) : v;
+    raw = raw.trim();
+    if (!raw) return null;
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  },
+};
+
+function parseOr(c: Cursor, vars: VarStack): unknown {
+  let left = parseAnd(c, vars);
+  while (isPunct(c, '||')) {
+    eat(c);
+    const right = parseAnd(c, vars);
+    left = truthy(left) || truthy(right);
+  }
+  return left;
+}
+
+// 三元表达式：cond ? true_expr : false_expr
+// 优先级低于 ||（即先算完 || 再判断 ? :）
+// 右结合：a ? b ? c : d : e 等价于 a ? (b ? c : d) : e
+function parseTernary(c: Cursor, vars: VarStack): unknown {
+  const cond = parseOr(c, vars);
+  if (!isPunct(c, '?')) return cond;
+  eat(c); // 吃掉 '?'
+  const consequent = parseTernary(c, vars); // 右结合：true 分支可以是嵌套三元
+  if (!isPunct(c, ':')) throw new Error("三元表达式缺少 ':'");
+  eat(c); // 吃掉 ':'
+  const alternate = parseTernary(c, vars); // 右结合：false 分支也可以是嵌套三元
+  return truthy(cond) ? consequent : alternate;
+}
+function parseAnd(c: Cursor, vars: VarStack): unknown {
+  let left = parseNot(c, vars);
+  while (isPunct(c, '&&')) {
+    eat(c);
+    const right = parseNot(c, vars);
+    left = truthy(left) && truthy(right);
+  }
+  return left;
+}
+function parseNot(c: Cursor, vars: VarStack): unknown {
+  if (isPunct(c, '!')) {
+    eat(c);
+    return !truthy(parseNot(c, vars));
+  }
+  return parseComparison(c, vars);
+}
+function parseComparison(c: Cursor, vars: VarStack): unknown {
+  const left = parseAdditive(c, vars);
+  const t = peek(c);
+  if (t && t.kind === 'punct' && ['==', '!=', '>=', '<=', '>', '<'].includes(t.value)) {
+    eat(c);
+    const right = parseAdditive(c, vars);
+    switch (t.value) {
+      case '==':
+        // eslint-disable-next-line eqeqeq
+        return left == right;
+      case '!=':
+        // eslint-disable-next-line eqeqeq
+        return left != right;
+      case '>':
+        return (left as number) > (right as number);
+      case '<':
+        return (left as number) < (right as number);
+      case '>=':
+        return (left as number) >= (right as number);
+      case '<=':
+        return (left as number) <= (right as number);
+    }
+  }
+  return left;
+}
+// 加法/拼接层：number + number → 相加；否则两边 stringify 后字符串拼接。
+// 表达式语言原本无拼接符，导致拼路径只能"先插值再 eval"（footgun 源头）；
+// 有了 + 之后可写 fileExists("videos/" + inputs.book + "/x") 这种纯表达式。
+function parseAdditive(c: Cursor, vars: VarStack): unknown {
+  let left = parsePrimary(c, vars);
+  while (isPunct(c, '+')) {
+    eat(c);
+    const right = parsePrimary(c, vars);
+    left = addValues(left, right);
+  }
+  return left;
+}
+
+function addValues(l: unknown, r: unknown): unknown {
+  if (typeof l === 'number' && typeof r === 'number') return l + r;
+  return stringify(l) + stringify(r);
+}
+function parsePrimary(c: Cursor, vars: VarStack): unknown {
+  const t = peek(c);
+  if (!t) throw new Error('表达式意外结束');
+
+  if (t.kind === 'punct' && t.value === '(') {
+    eat(c);
+    // 括号内是完整表达式（含三元）——曾只递归 parseOr，(a ? b : c) 报「缺少 ')'」
+    const v = parseTernary(c, vars);
+    if (!isPunct(c, ')')) throw new Error("缺少 ')'");
+    eat(c);
+    return v;
+  }
+  if (t.kind === 'punct' && t.value === '[') {
+    eat(c);
+    const arr: unknown[] = [];
+    if (!isPunct(c, ']')) {
+      arr.push(parseTernary(c, vars));
+      while (isPunct(c, ',')) {
+        eat(c);
+        arr.push(parseTernary(c, vars));
+      }
+    }
+    if (!isPunct(c, ']')) throw new Error("缺少 ']'");
+    eat(c);
+    return arr;
+  }
+  if (t.kind === 'num') {
+    eat(c);
+    return t.value;
+  }
+  if (t.kind === 'str') {
+    eat(c);
+    // 字符串字面量支持内嵌 ${...} 插值（template-literal 语义）：
+    // fileExists("videos/${inputs.book}/x") 不必预插值也能工作。无 ${} 时原样返回。
+    return interpolate(t.value, vars);
+  }
+  if (t.kind === 'interp') {
+    eat(c);
+    // 独立 ${EXPR}：求值为 EXPR 的"值"（任意类型，不字符串化）。
+    // 修掉"裸 ${x} == 'y' 被当成变量名 x"的 footgun。
+    return evalExpr(t.value, vars);
+  }
+  if (t.kind === 'ident') {
+    eat(c);
+    // 函数调用？
+    if (isPunct(c, '(')) {
+      eat(c);
+      const argv: unknown[] = [];
+      if (!isPunct(c, ')')) {
+        argv.push(parseTernary(c, vars));
+        while (isPunct(c, ',')) {
+          eat(c);
+          argv.push(parseTernary(c, vars));
+        }
+      }
+      if (!isPunct(c, ')')) throw new Error("缺少 ')'");
+      eat(c);
+      const fn = BUILTINS[t.value];
+      if (!fn) throw new Error(`未知函数 "${t.value}"。白名单：${Object.keys(BUILTINS).join(', ')}`);
+      return fn(argv);
+    }
+    // 字面常量
+    if (t.value === 'true') return true;
+    if (t.value === 'false') return false;
+    if (t.value === 'null') return null;
+    // 变量 + 点路径
+    let cur: unknown = vars.get(t.value);
+    while (isPunct(c, '.')) {
+      eat(c);
+      const next = eat(c);
+      if (next.kind !== 'ident') throw new Error('点号后必须是标识符');
+      // S1：禁止经点路径访问原型链（__proto__ / constructor / prototype），防原型污染 / 函数对象逃逸。
+      if (
+        next.value === '__proto__' ||
+        next.value === 'constructor' ||
+        next.value === 'prototype'
+      ) {
+        cur = undefined;
+      } else {
+        cur =
+          cur != null && typeof cur === 'object'
+            ? (cur as Record<string, unknown>)[next.value]
+            : undefined;
+      }
+    }
+    return cur;
+  }
+  throw new Error(`无法解析 token: ${JSON.stringify(t)}`);
+}
+
+function truthy(v: unknown): boolean {
+  if (v === null || v === undefined) return false;
+  if (typeof v === 'boolean') return v;
+  if (typeof v === 'number') return v !== 0 && !Number.isNaN(v);
+  if (typeof v === 'string') return v.length > 0;
+  if (Array.isArray(v)) return v.length > 0;
+  if (typeof v === 'object') return Object.keys(v).length > 0;
+  return true;
+}
+
+// ---------------- 对外 API ----------------
+
+/** 计算表达式（裸的，不带 ${} 包裹）。失败抛错。 */
+export function evalExpr(expr: string, vars: VarStack): unknown {
+  const toks = tokenize(expr);
+  if (toks.length === 0) return undefined;
+  const cursor: Cursor = { toks, pos: 0 };
+  const v = parseTernary(cursor, vars);
+  if (cursor.pos !== toks.length) {
+    throw new Error(`表达式多余 token: "${expr}"`);
+  }
+  return v;
+}
+
+/**
+ * interpolate / interpolateDeep 的可选项。
+ * onMissing：某个 ${EXPR} 求值为 undefined（变量不存在/点路径落空）时回调。
+ * 设计动机：未定义变量静默插成空串是 ralph-loop 裸 ${goal} 渲染为空的病根——
+ * 引擎不能猜作者意图（undefined 可能是合法的可选值），但**必须可见化**；
+ * 执行器收集后 yield 一条 warning（含表达式原文），作者一眼定位拼写/命名空间错误。
+ */
+export interface InterpolateOptions {
+  onMissing?: (expr: string) => void;
+}
+
+/**
+ * 字符串插值：把 "${EXPR}" 替换成 EXPR 求值结果。
+ * 多个 ${} 串联也支持。括号配对识别 —— "${ ${nested} }" 会被当成一个外层
+ * EXPR（内部 ${nested} 文本原样，但表达式里不允许 ${} 语法，所以会报错）。
+ *
+ * 转义：`\$` → 字面 $，跳过插值。
+ */
+export function interpolate(
+  template: string,
+  vars: VarStack,
+  opts?: InterpolateOptions,
+): string {
+  let out = '';
+  let i = 0;
+  while (i < template.length) {
+    const c = template[i];
+    if (c === '\\' && template[i + 1] === '$') {
+      out += '$';
+      i += 2;
+      continue;
+    }
+    if (c === '$' && template[i + 1] === '{') {
+      // 找匹配的 '}'
+      let depth = 1;
+      let j = i + 2;
+      while (j < template.length && depth > 0) {
+        if (template[j] === '{') depth++;
+        else if (template[j] === '}') depth--;
+        if (depth > 0) j++;
+      }
+      if (depth !== 0) {
+        // 不匹配；原样输出
+        out += template.slice(i);
+        return out;
+      }
+      const expr = template.slice(i + 2, j);
+      const v = evalExpr(expr, vars);
+      if (v === undefined) opts?.onMissing?.(expr);
+      out += stringify(v);
+      i = j + 1;
+      continue;
+    }
+    out += c;
+    i++;
+  }
+  return out;
+}
+
+/**
+ * 类型保留插值：模板整串恰好是单一 "${EXPR}" 时直接返回 EXPR 的值
+ * （布尔/数字/数组原样，不字符串化）；多片段模板退回普通 interpolate。
+ * 非字符串值原样透传（与 interpolateDeep 对非字符串的行为一致）。
+ *
+ * 动机：set 步写 `flag: "${qualified}"` 曾被字符串化成 "true"，逼出下游
+ * 满篇 `== true || == 'true'` 防御——单表达式赋值就该保住类型。
+ */
+export function interpolateTyped(
+  value: unknown,
+  vars: VarStack,
+  opts?: InterpolateOptions,
+): unknown {
+  if (typeof value !== 'string') return value;
+  const expr = singleExprOf(value);
+  if (expr === null) return interpolate(value, vars, opts);
+  const v = evalExpr(expr, vars);
+  if (v === undefined) opts?.onMissing?.(expr);
+  return v;
+}
+
+/** 整串恰好是一个 "${EXPR}"（括号配对到串尾）时返回内层 EXPR，否则 null。 */
+function singleExprOf(template: string): string | null {
+  if (!template.startsWith('${') || !template.endsWith('}')) return null;
+  let depth = 1;
+  for (let j = 2; j < template.length; j++) {
+    if (template[j] === '{') depth++;
+    else if (template[j] === '}') {
+      depth--;
+      // 提前归零 = 中途闭合（如 "${a}-${b}"），不是单一表达式
+      if (depth === 0) return j === template.length - 1 ? template.slice(2, j) : null;
+    }
+  }
+  return null;
+}
+
+function stringify(v: unknown): string {
+  if (v === null || v === undefined) return '';
+  if (typeof v === 'string') return v;
+  if (typeof v === 'number' || typeof v === 'boolean') return String(v);
+  try {
+    return JSON.stringify(v);
+  } catch {
+    return String(v);
+  }
+}
+
+/** 递归对对象/数组/字符串做插值；其它原样返回。 */
+export function interpolateDeep<T>(
+  value: T,
+  vars: VarStack,
+  opts?: InterpolateOptions,
+): T {
+  if (typeof value === 'string') {
+    return interpolate(value, vars, opts) as unknown as T;
+  }
+  if (Array.isArray(value)) {
+    return value.map((v) => interpolateDeep(v, vars, opts)) as unknown as 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 有意义
+      const newKey = interpolate(k, vars, opts);
+      out[newKey] = interpolateDeep(v, vars, opts);
+    }
+    return out as unknown as T;
+  }
+  return value;
+}

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

@@ -10,9 +10,9 @@
  *  不污染默认 T-A-O-R 路径。
  * ============================================================
  */
+import { buildBaseSystemPrompt, } from '../../../src/plugin-sdk.js';
 import { findWorkflowByName, listWorkflows } from './loader.js';
 import { runWorkflow } from './runner.js';
-import { buildFullSystemPrompt, } from '../../../src/plugin-sdk.js';
 /**
  * 把 "/workflow <name> [pos1 pos2 ...] [--input k=v ...]" 拆成 name + 显式 inputs + 位置参数。
  * 简单解析器（不依赖第三方）：
@@ -103,7 +103,7 @@ function coerceInputs(raw, defs) {
             continue;
         }
         if (def.type === 'number') {
-            const n = parseFloat(rawVal);
+            const n = Number.parseFloat(rawVal);
             if (Number.isNaN(n))
                 throw new Error(`input ${def.name} 必须是数字，收到 "${rawVal}"`);
             out[def.name] = n;
@@ -126,7 +126,9 @@ function coerceInputs(raw, defs) {
     return out;
 }
 async function refreshWorkflowSystemPrompt(history, cwd, tools) {
-    const content = await buildFullSystemPrompt(cwd, tools);
+    // 只刷稳定层：workflow 一跑就是几十步，system 消息若含日期/记忆等易变内容，
+    // 每步都会重写 history[0]、把 provider 前缀缓存打散（见 prompts/system.ts）。
+    const content = await buildBaseSystemPrompt(cwd, tools);
     const systemIndex = history.findIndex((m) => m.role === 'system' && !m._ephemeral);
     const fresh = { role: 'system', content };
     if (systemIndex === 0) {
@@ -217,11 +219,18 @@ export async function* runWorkflowFromCommand(rawArgs, opts) {
     }
     const ctx = {
         provider: opts.provider,
+        runtimeContext: opts.runtimeContext,
         signal: opts.signal,
         history: opts.history,
         sessionState: opts.sessionState,
         cwd,
         tools,
+        host: opts.host,
+        transientContext: opts.transientContext,
+        transientBundle: opts.transientBundle,
+        promptCache: opts.promptCache,
+        executeTool: opts.executeTool,
+        toolContext: opts.toolContext,
     };
     // 透传 runWorkflow 的事件，并观察是否出现终结事件（error / interrupted = 失败或中断，
     // 与 gateway broker 的 TERMINAL 判定同一套逻辑）。成功（没见到终结事件）则在末尾补一条
@@ -258,6 +267,6 @@ export async function* runWorkflowsList() {
     lines.push('  /workflow <name> <val>            位置参数（按 inputs 声明顺序，第一个 input 直接写值）');
     lines.push('  /workflow <name>.yaml <val>       .yaml 后缀可省');
     lines.push('  /workflow <name> --input k=v      显式 KV（多 input 或想跳过中间 input 时用）');
-    yield { type: 'text', delta: lines.join('\n') + '\n' };
+    yield { type: 'text', delta: `${lines.join('\n')}\n` };
     yield { type: 'turn_done' };
 }