minimal-agent 0.10.0 → 0.12.0

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

@@ -0,0 +1,234 @@
+/**
+ * ============================================================
+ *  plugins/workflow-runner/src/stepExecutors/agent.ts —— agent 步骤执行器
+ * ------------------------------------------------------------
+ *  v0.9 重构：不再使用独立 miniReAct 子循环，而是委托主 TAOR 引擎
+ *  （runQuery / src/loop.ts）执行。这样做的好处：
+ *
+ *    1. 上下文自然积累：每步的完整对话（user→assistant→tool→...）
+ *       都写入共享 history，后续步骤和用户对话都能看到
+ *    2. 工具/skills/插件信息来自系统提示词（history[0]），无需重复组装
+ *    3. 压缩自动生效：history 增长时 autoCompact / reactiveCompact 自动触发
+ *    4. Token 消耗透明：TUI status 行实时显示真实 token 数
+ *    5. 中断后上下文完整：已完成的步骤全在 history 里，可继续/调整
+ *
+ *  与 llm 步的区别：
+ *    - agent 有 maxTurns 上限（默认 25），允许多轮工具调用
+ *    - agent 的产出经过验证闸门（interpretMiniReActResult）
+ *    - llm 只跑单轮 chat（maxTurns=1）
+ * ============================================================
+ */
+
+import type { LoopEvent } from '../../../../src/plugin-sdk.js';
+import {
+  type StepQueryOutcome,
+  describeCaptureContract,
+  describeLlmFailure,
+  describeMaxTurnsCutoff,
+  effectiveGoalAnchor,
+  interpretMiniReActResult,
+  runStepQuery,
+} from '../agentCommon.js';
+import { evalExpr, interpolate } from '../expressions.js';
+import { resolveWorkflowMultimodalOptions } from '../multimodal.js';
+import type { RunContext, StepDef, StepResult, VarStack } from '../types.js';
+
+/**
+ * 执行一个 agent 步骤：构造 step prompt → 委托 runQuery(TAOR) → 提取结果。
+ *
+ * runQuery 会：
+ *   1. 把 prompt 作为 user message push 进 ctx.history
+ *   2. 跑 TAOR 循环（调 LLM → 执行工具 → 喂回 → 直到模型不调工具）
+ *   3. 把所有 assistant / tool 消息 push 进 ctx.history
+ *   4. yield UI 事件（text_delta / tool_start / tool_end / ...）
+ */
+export async function* execAgentStep(
+  step: StepDef,
+  vars: VarStack,
+  ctx: RunContext,
+): AsyncGenerator<LoopEvent, StepResult, void> {
+  // 默认 25（与 skill 步 skill.ts 对齐）。agent 步本就是「开放多工具任务」执行器，
+  // 弱模型常一轮只调一个工具（Read/Grep/Glob 各占一轮），旧默认 12 对探索类步骤
+  // （如 plan.yaml stage1_research）太紧——12 轮还没收集完就撞顶截断、误判失败。
+  // 这是安全阀不是性能阀；要更紧的步显式写小值即可。
+  const maxTurns = step.maxTurns ?? 25;
+
+  // 未定义变量插值可见化（裸 ${goal} 这类拼写/命名空间错的病根，静默空串会坑死下游）
+  const missing: string[] = [];
+  const iopts = { onMissing: (e: string) => missing.push(e) };
+
+  // 构造用户提示：包含步骤指令 + 变量 + capture 约束 + 内部标记防护
+  const userPrompt = `${interpolate(step.agent ?? '', vars, iopts)}${describeCaptureContract(step)}${step.input ? `\n\n上下文变量：${interpolate(step.input, vars, iopts)}` : ''}\n\n⚠️ 输出规范：直接输出你的工作成果即可，不要在输出中包含任何类似「放弃」、「GIVEUP」、「__AGENT__」或「[wf-internal」的内部标记文本。`;
+
+  // 如果有 output_schema，把 schema 约束嵌入 prompt（runQuery 不原生支持 responseFormat）
+  const schemaHint = step.output_schema
+    ? `\n\n【结构化输出约束】请严格按照以下 JSON Schema 输出结果（不要包裹在 markdown 代码块中）：\n${JSON.stringify(step.output_schema, null, 2)}`
+    : '';
+
+  const fullPrompt = userPrompt + schemaHint;
+
+  // 通用目标锚定（原始目标 + 累积的用户补充要求），前置注入 prompt。
+  // 确保每步 LLM 都能看到用户原始目标与运行中的补充要求，
+  // 避免长上下文 / fresh_context 导致目标被稀释或遗忘。
+  const anchor = effectiveGoalAnchor(ctx);
+  const effectivePrompt = anchor ? `${anchor}\n\n${fullPrompt}` : fullPrompt;
+
+  const multimodal = resolveWorkflowMultimodalOptions(step, vars, ctx, (e) =>
+    missing.push(e),
+  );
+
+  if (missing.length > 0) {
+    yield {
+      type: 'warning',
+      message: `step "${step.id}": 模板变量未定义，已按空串插值：${[...new Set(missing)].map((m) => `\${${m}}`).join('、')}（裸名请用 inputs.<name> 或先 capture/set）`,
+    };
+  }
+
+  // 委托 TAOR 引擎执行（共享消费层 runStepQuery：携带 sessionState 以启用上下文压缩，
+  // 并统一侦测终结错误——runQuery 遇 LLM 失败是 yield error 后 return 不 throw）。
+  const {
+    rawText,
+    sawToolCall,
+    toolNames,
+    toolOkCount,
+    toolFailCount,
+    aborted,
+    sawLlmError,
+    sawMaxTurns,
+    llmErrorDetail,
+  } = yield* runStepQuery(effectivePrompt, step, ctx, {
+    maxTurns,
+    ...multimodal,
+  });
+
+  const stepResult: StepResult = {
+    raw: { text: rawText, result: rawText },
+    preview: rawText.length > 200 ? `${rawText.slice(0, 200)}...` : rawText,
+  };
+
+  // 用户中断导致的空产出：不过验证闸门（否则会误抛「放弃: 没有产出任何结果」），
+  // 直接返回当前（可能为空的）结果，由 runner 据 signal.aborted 收口（不当作可重试失败）。
+  if (aborted) return stepResult;
+
+  // P0-1（同 llm.ts / skill.ts）：LLM 失败（超时/网络错）且本步无任何产出 →
+  // 抛「可重试失败」交给 runner 的 in-run retry。必须在验证闸门之前——
+  // 否则 provider 故障会被闸门误归因为「agent 步骤放弃: 没有产出任何结果」，
+  // 混淆「provider 失败（该重试）」与「模型真放弃/空答（诚实 halt）」。
+  if (!rawText.trim() && sawLlmError) {
+    // 抛错文案附带 provider 真实报错（经 runner 落 progress.md，刷屏后仍可排障）
+    throw new Error(describeLlmFailure(step.id, llmErrorDetail));
+  }
+
+  // 撞 maxTurns 截断：截断时刻的文本是半截工作叙述，不是可信交付——
+  // 即使非空也不能过闸门（曾被静默当成功：半成品 PPTX 被整条链当真交付）。
+  // 抛可重试失败 → in-run retry 在共享 history 上续作（模型看到已有进度接着干）。
+  if (sawMaxTurns) {
+    throw new Error(describeMaxTurnsCutoff(step.id, maxTurns));
+  }
+
+  // done_when 验收兜底（K3/A2）：弱模型常「宣告要干活」却不调工具就 end_turn
+  //（announce-not-do，2026-06-12 plan 工作流实跑事故的执行步烂尾根因之一）。
+  // yaml 作者声明确定性完成条件（如 fileExists('./doc/x.pptx')），不满足时
+  // 引擎自动 nudge 同一 agent 在共享 history 上继续干（看得到自己刚才的半截工作），
+  // 把「对抗模型不可靠」从每个 yaml 的 prompt 工程收回引擎单点。
+  if (step.done_when) {
+    const NUDGES = 2; // 提醒上限：超过说明模型真干不动，交给 onError/max_retries
+    let result = resultIfTextLooksDeliverable(step, rawText);
+    let lastOutcome = {
+      rawText,
+      sawToolCall,
+      toolNames,
+      toolOkCount,
+      toolFailCount,
+    };
+    for (let n = 0; ; n++) {
+      if (evalDoneWhen(step, vars)) {
+        return result ?? doneWhenSatisfiedResult(step);
+      }
+      if (n >= NUDGES) {
+        throw new Error(
+          `agent 步骤 "${step.id}" 完成条件未满足（done_when: ${step.done_when}），已提醒 ${NUDGES} 次仍未达成。${describeAttemptForDoneWhen(lastOutcome)}`,
+        );
+      }
+      yield {
+        type: 'warning',
+        message: `⏩ step "${step.id}" 完成条件未满足（${step.done_when}），提醒 agent 继续执行（第 ${n + 1}/${NUDGES} 次）。${describeAttemptForDoneWhen(lastOutcome)}`,
+      };
+      const nudge = yield* runStepQuery(
+        `检查发现这一步还没有真正完成：完成条件 \`${step.done_when}\` 仍不成立。不要解释、不要宣告计划——继续实际执行（调用工具落盘/操作），直到完成条件成立，然后给出简短完成报告。`,
+        step,
+        ctx,
+        { maxTurns },
+      );
+      if (nudge.aborted) return result ?? stepResult;
+      if (!nudge.rawText.trim() && nudge.sawLlmError) {
+        throw new Error(describeLlmFailure(step.id, nudge.llmErrorDetail));
+      }
+      if (nudge.sawMaxTurns) {
+        throw new Error(describeMaxTurnsCutoff(step.id, maxTurns));
+      }
+      lastOutcome = nudge;
+      if (nudge.rawText.trim()) {
+        result = resultIfTextLooksDeliverable(step, nudge.rawText) ?? result;
+      }
+    }
+  }
+
+  // 验证闸门：判断结果是"真交付"还是"放弃"。注意：带 done_when 的步骤已在上方
+  // 由确定性条件验收，避免"文件已落盘但最终空文本"或"还没落盘但空文本"绕过 nudge。
+  const outcome = interpretMiniReActResult(stepResult, !!step.output_schema);
+  if (!outcome.ok) throw new Error(`agent 步骤放弃: ${outcome.reason}`);
+
+  return outcome.value;
+}
+
+function evalDoneWhen(step: StepDef, vars: VarStack): boolean {
+  try {
+    return Boolean(evalExpr(step.done_when ?? '', vars));
+  } catch (e) {
+    // 表达式坏了是 yaml 作者错误：响亮失败（同 max_iterations 解析失败哲学），
+    // 不能静默当 false 把好结果 nudge 死、也不能静默当 true 放走烂尾。
+    throw new Error(
+      `step "${step.id}" 的 done_when 表达式求值失败: ${(e as Error).message}`,
+    );
+  }
+}
+
+function doneWhenSatisfiedResult(step: StepDef): StepResult {
+  const text = `完成条件已满足：${step.done_when}`;
+  return { raw: { text, result: text, content: text }, preview: text };
+}
+
+function resultIfTextLooksDeliverable(step: StepDef, text: string): StepResult | null {
+  if (!text.trim()) return null;
+  const outcome = interpretMiniReActResult(
+    {
+      raw: { text, result: text },
+      preview: text.length > 200 ? `${text.slice(0, 200)}...` : text,
+    },
+    !!step.output_schema,
+  );
+  return outcome.ok ? outcome.value : null;
+}
+
+type DoneWhenAttemptSummary = Pick<
+  StepQueryOutcome,
+  'rawText' | 'sawToolCall' | 'toolNames' | 'toolOkCount' | 'toolFailCount'
+>;
+
+function describeAttemptForDoneWhen(outcome: DoneWhenAttemptSummary): string {
+  const textState = outcome.rawText.trim()
+    ? '本轮有文本报告'
+    : '本轮没有文本报告';
+  if (!outcome.sawToolCall) {
+    return `${textState}，且没有观察到工具调用；请不要只宣告计划，必须调用工具完成产物。`;
+  }
+  const names = outcome.toolNames.length ? outcome.toolNames.join('、') : '未知工具';
+  const wrote = outcome.toolNames.some((name) =>
+    ['Write', 'Edit', 'MultiEdit', 'Bash'].includes(name),
+  );
+  const writeHint = wrote
+    ? '已观察到写入类工具调用，但完成条件仍未满足，请检查路径或实际写入结果'
+    : '未观察到写入类工具调用，请立即调用 Write/Edit/Bash 落盘产物';
+  return `${textState}；本轮工具调用：${names}（成功 ${outcome.toolOkCount}，失败 ${outcome.toolFailCount}）。${writeHint}。`;
+}

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

@@ -0,0 +1,50 @@
+/**
+ * ============================================================
+ *  plugins/workflow-runner/src/stepExecutors/assert.ts —— assert step 执行
+ * ------------------------------------------------------------
+ *  evalExpr(condition) → 真值通过；假值抛错（带 onFail 自定义信息）。
+ *
+ *  v0.9.3（上下文统一修复）：assert 步骤通过后也写入 ctx.history，
+ *  让后续 LLM 步骤能看到验证通过的信息（如"文件已存在""变量值符合预期"等）。
+ * ============================================================
+ */
+
+import { evalExpr, interpolate } from '../expressions.js';
+import type { RunContext, StepDef, StepResult, VarStack } from '../types.js';
+
+export function execAssertStep(
+  step: StepDef,
+  vars: VarStack,
+  ctx: RunContext, // 必填：runner 唯一调用点（dispatchActionStep）始终传 ctx，
+  //                  与 tool/agent/llm/skill 执行器签名对齐（编译期强制，不再可选）
+): StepResult {
+  if (typeof step.condition !== 'string') {
+    throw new Error(`step ${step.id}: assert 缺少 condition`);
+  }
+  let ok: boolean;
+  try {
+    ok = Boolean(evalExpr(step.condition, vars));
+  } catch (e) {
+    throw new Error(`assert 表达式求值失败: ${(e as Error).message}`);
+  }
+  if (!ok) {
+    const msg = step.onFail
+      ? interpolate(step.onFail, vars)
+      : `assertion failed: ${step.condition}`;
+    throw new Error(msg);
+  }
+
+  // ════ v0.9.3：上下文统一 —— assert 通过也留痕 ════
+  // 让后续 LLM 步骤知道某个前置条件/不变量已确认满足。
+  // ctx 必填（签名强制，runner 唯一调用点 dispatchActionStep 始终传），直接访问 history。
+  if (ctx.history) {
+    ctx.history.push({
+      role: 'assistant',
+      content: `[workflow:${step.id}] ✅ 断言通过：${step.condition}`,
+      timestamp: Date.now(),
+      id: crypto.randomUUID(),
+    });
+  }
+
+  return { raw: { ok: true }, preview: 'assert passed' };
+}

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

@@ -0,0 +1,31 @@
+/**
+ * ============================================================
+ *  stepExecutors/echo.ts —— 确定性输出插值消息给用户
+ * ------------------------------------------------------------
+ *  从 `runner.ts::runSteps` 的内联块搬出来。它的价值在于「不烧 LLM、零幻觉」：
+ *  完成报告用它而不是让模型复述。
+ *
+ *  搬出来之后走统一提交流水线，于是 **`capture:` 自然生效**（捕获它输出的文本）——
+ *  此前 echo 从不调 `bindCapture`、checkpoint 里记的是 `{}`，
+ *  yaml 写了 `capture` 既不报错也不生效，resume 时也回放不出来。
+ *
+ *  ⚠️ 未定义变量按**空串**插值并发 warning（与 set 的「响亮报错」不同）：
+ *  echo 是给人看的文案，缺个变量不该让整条工作流停下，但也不能悄悄少一段。
+ * ============================================================
+ */
+import { truncate } from '../agentCommon.js';
+import { interpolate } from '../expressions.js';
+export async function* execEchoStep(step, vars) {
+    const missing = [];
+    const text = interpolate(step.message ?? '', vars, {
+        onMissing: (e) => missing.push(e),
+    });
+    if (missing.length > 0) {
+        yield {
+            type: 'warning',
+            message: `step "${step.id}": 模板变量未定义，已按空串插值：${[...new Set(missing)].map((m) => `\${${m}}`).join('、')}`,
+        };
+    }
+    yield { type: 'text', delta: text.endsWith('\n') ? text : `${text}\n` };
+    return { raw: { text, result: text }, preview: truncate(text, 200) };
+}

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

@@ -0,0 +1,38 @@
+/**
+ * ============================================================
+ *  stepExecutors/echo.ts —— 确定性输出插值消息给用户
+ * ------------------------------------------------------------
+ *  从 `runner.ts::runSteps` 的内联块搬出来。它的价值在于「不烧 LLM、零幻觉」：
+ *  完成报告用它而不是让模型复述。
+ *
+ *  搬出来之后走统一提交流水线，于是 **`capture:` 自然生效**（捕获它输出的文本）——
+ *  此前 echo 从不调 `bindCapture`、checkpoint 里记的是 `{}`，
+ *  yaml 写了 `capture` 既不报错也不生效，resume 时也回放不出来。
+ *
+ *  ⚠️ 未定义变量按**空串**插值并发 warning（与 set 的「响亮报错」不同）：
+ *  echo 是给人看的文案，缺个变量不该让整条工作流停下，但也不能悄悄少一段。
+ * ============================================================
+ */
+
+import type { LoopEvent } from '../../../../src/plugin-sdk.js';
+import { truncate } from '../agentCommon.js';
+import { interpolate } from '../expressions.js';
+import type { StepDef, StepResult, VarStack } from '../types.js';
+
+export async function* execEchoStep(
+  step: StepDef,
+  vars: VarStack,
+): AsyncGenerator<LoopEvent, StepResult, void> {
+  const missing: string[] = [];
+  const text = interpolate(step.message ?? '', vars, {
+    onMissing: (e: string) => missing.push(e),
+  });
+  if (missing.length > 0) {
+    yield {
+      type: 'warning',
+      message: `step "${step.id}": 模板变量未定义，已按空串插值：${[...new Set(missing)].map((m) => `\${${m}}`).join('、')}`,
+    } as LoopEvent;
+  }
+  yield { type: 'text', delta: text.endsWith('\n') ? text : `${text}\n` };
+  return { raw: { text, result: text }, preview: truncate(text, 200) };
+}

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

@@ -0,0 +1,133 @@
+/**
+ * ============================================================
+ *  plugins/workflow-runner/src/stepExecutors/llm.ts —— llm 步骤执行器
+ * ------------------------------------------------------------
+ *  v0.9 重构：不再使用独立 miniReAct 子循环或裸 chat()，而是委托主 TAOR 引擎
+ *  （runQuery / src/loop.ts）执行。
+ *
+ *  与 agent 步的区别：
+ *    - llm 默认单轮（maxTurns=1），不下发工具
+ *    - 有 context_files 或 allowed_tools 时允许少量轮次读取文件后输出
+ *    - output_schema 嵌入 prompt 作为结构化约束
+ *    - 不经过 interpretMiniReActResult 验证闸门（直接信任 LLM 输出）
+ *
+ *  capture：
+ *    - `{ text: var_name }` 绑生成文本
+ *    - `{ <field>: var_name }` 当 output_schema 存在时按 JSON 字段取值
+ * ============================================================
+ */
+
+import type { LoopEvent } from '../../../../src/plugin-sdk.js';
+import {
+  describeLlmFailure,
+  describeMaxTurnsCutoff,
+  effectiveGoalAnchor,
+  runStepQuery,
+} from '../agentCommon.js';
+import { interpolate } from '../expressions.js';
+import { extractJsonPayload } from '../jsonPayload.js';
+import { resolveWorkflowMultimodalOptions } from '../multimodal.js';
+import type { RunContext, StepDef, StepResult, VarStack } from '../types.js';
+
+export async function* execLlmStep(
+  step: StepDef,
+  vars: VarStack,
+  ctx: RunContext,
+): AsyncGenerator<LoopEvent, StepResult, void> {
+  if (typeof step.llm !== 'string') throw new Error(`step ${step.id}: 缺少 llm 字段`);
+
+  // 未定义变量插值可见化（静默空串是下游 prompt 留白的病根）
+  const missing: string[] = [];
+  const iopts = { onMissing: (e: string) => missing.push(e) };
+
+  const prompt = interpolate(step.llm, vars, iopts);
+
+  // 有 context_files → 在 prompt 中附上文件列表，runQuery 的 TAOR 循环中
+  // 模型可自主用 Read 工具读取（ALL_TOOLS 全量可用）
+  let fullPrompt = prompt;
+  if (step.context_files && step.context_files.length > 0) {
+    const fileList = step.context_files
+      .map((f) => `- ${interpolate(f.path, vars, iopts)}${f.hint ? ` — ${f.hint}` : ''}`)
+      .join('\n');
+    fullPrompt = `${prompt}\n\n**以下上下文文件可用，请用 Read 工具按需读取**：\n${fileList}`;
+  }
+
+  // output_schema 约束嵌入 prompt
+  const schemaHint = step.output_schema
+    ? `\n\n【结构化输出约束】请严格按照以下 JSON Schema 输出有效 JSON 对象本身（不要 markdown 代码块包裹）：\n${JSON.stringify(step.output_schema, null, 2)}`
+    : '';
+
+  fullPrompt += schemaHint;
+
+  // 通用目标锚定（原始目标 + 补充要求）：同 agent.ts，确保每步 LLM 不偏离
+  const anchor = effectiveGoalAnchor(ctx);
+  const effectivePrompt = anchor ? `${anchor}\n\n${fullPrompt}` : fullPrompt;
+
+  const needsTools = !!step.context_files?.length || step.allowed_tools !== undefined;
+  const queryStep = needsTools ? step : { ...step, allowed_tools: [] };
+
+  // llm 步默认单轮；需要工具时允许多轮（读文件→输出）
+  const maxTurns = step.maxTurns ?? (step.context_files?.length ? 10 : 1);
+
+  const multimodal = resolveWorkflowMultimodalOptions(step, vars, ctx, (e) =>
+    missing.push(e),
+  );
+
+  if (missing.length > 0) {
+    yield {
+      type: 'warning',
+      message: `step "${step.id}": 模板变量未定义，已按空串插值：${[...new Set(missing)].map((m) => `\${${m}}`).join('、')}（裸名请用 inputs.<name> 或先 capture/set）`,
+    };
+  }
+
+  // 委托 TAOR 引擎执行（共享消费层 runStepQuery：携带 sessionState 以启用上下文压缩，
+  // 并统一侦测终结错误——runQuery 遇 LLM 失败是 yield error 后 return 不 throw，
+  // 直透会让本步静默返回空文本、runner 的 in-run retry 不触发 → 产出空如空 PLAN.md）。
+  const { rawText, aborted, sawLlmError, sawMaxTurns, llmErrorDetail } =
+    yield* runStepQuery(effectivePrompt, queryStep, ctx, {
+      maxTurns,
+      ...multimodal,
+    });
+
+  const trimmed = rawText.trim();
+
+  // P0-1：LLM 失败（超时/网络错）且本步无任何产出 → 抛异常，触发 runner 的 max_retries 重跑。
+  // 必须放在 output_schema 解析之前（空文本本就无法解析），且只在 !aborted 时抛
+  // （用户中断不该被当成可重试失败；aborted 时按现状返回空结果即可）。
+  if (!trimmed && sawLlmError && !aborted) {
+    throw new Error(describeLlmFailure(step.id, llmErrorDetail));
+  }
+
+  // 撞 maxTurns 截断 → 截断时产出不可信，抛可重试失败（续作语义，同 agent.ts）
+  if (sawMaxTurns && !aborted) {
+    throw new Error(describeMaxTurnsCutoff(step.id, maxTurns));
+  }
+
+  // 结构化输出模式：解析 JSON
+  if (step.output_schema) {
+    const payload = extractJsonPayload(trimmed);
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(payload);
+    } catch (e) {
+      throw new Error(
+        `step ${step.id}: output_schema 要求 JSON 输出但解析失败: ${(e as Error).message}\n收到: ${trimmed.slice(0, 200)}`,
+      );
+    }
+    if (parsed === null || typeof parsed !== 'object') {
+      throw new Error(
+        `step ${step.id}: output_schema 要求对象输出，得到 ${typeof parsed}: ${trimmed.slice(0, 100)}`,
+      );
+    }
+    return {
+      raw: parsed as Record<string, unknown>,
+      preview: `[json] ${trimmed.slice(0, 180)}${trimmed.length > 180 ? '...' : ''}`,
+    };
+  }
+
+  // 裸文本模式
+  return {
+    raw: { text: trimmed, result: trimmed },
+    preview: trimmed.length > 200 ? `${trimmed.slice(0, 200)}...` : trimmed,
+  };
+}

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

@@ -0,0 +1,49 @@
+/**
+ * ============================================================
+ *  stepExecutors/set.ts —— 确定性变量赋值
+ * ------------------------------------------------------------
+ *  从 `runner.ts::runSteps` 的内联块搬出来。搬出来的收益不只是「runner 短了 40 行」：
+ *  它现在走**统一的提交流水线**（`stepPipeline.ts::commitStep`），于是
+ *  **`capture:` 自然生效了** —— 此前 set 从不调 `bindCapture`、checkpoint 里
+ *  记的是 `resolved` 而非 `collectCaptured(...)`，yaml 作者写了 `capture` 既不
+ *  报错也不生效，resume 时也回放不出来。典型的静默失效。
+ *
+ *  ⚠️ 两个必须保住的语义：
+ *   ① 写的是 `vars.setGlobal`（根帧）不是 `vars.set` —— set 步声明的是**工作流级**
+ *     变量，在循环体里写也必须活到循环之外。
+ *   ② 顶层值若是单一 `"${EXPR}"` 模板走 `interpolateTyped` **保留类型**
+ *     （布尔/数字/数组不字符串化成 "true"，下游条件不必写 `== true || == 'true'` 防御）；
+ *     多片段模板与嵌套结构走 `interpolateDeep`，行为不变。
+ * ============================================================
+ */
+import { interpolateDeep, interpolateTyped } from '../expressions.js';
+export async function* execSetStep(step, vars) {
+    const missing = [];
+    const resolved = {};
+    for (const [k, v] of Object.entries(step.set ?? {})) {
+        resolved[k] =
+            typeof v === 'string'
+                ? interpolateTyped(v, vars, { onMissing: (e) => missing.push(e) })
+                : interpolateDeep(v, vars, { onMissing: (e) => missing.push(e) });
+    }
+    if (missing.length > 0) {
+        yield {
+            type: 'warning',
+            message: `step "${step.id}": 模板变量未定义：${[...new Set(missing)].map((m) => `\${${m}}`).join('、')}（裸名请用 inputs.<name> 或先 capture/set）`,
+        };
+    }
+    for (const [k, v] of Object.entries(resolved)) {
+        vars.setGlobal(k, v);
+    }
+    const summary = Object.entries(resolved)
+        .map(([k, v]) => `${k}=${String(v).slice(0, 40)}`)
+        .join(', ');
+    // raw 就是赋值表本身 —— 这样 `capture: { <变量名>: <别名> }` 能取到刚赋的值。
+    // replayVars 让 checkpoint 记下这些赋值：resume 跳过本步时变量仍能回放
+    //（set 步通常没有 capture:，只靠 collectCaptured 会记成 {}）。
+    return {
+        raw: { ...resolved },
+        replayVars: { ...resolved },
+        preview: `set: ${summary}`,
+    };
+}

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

@@ -0,0 +1,56 @@
+/**
+ * ============================================================
+ *  stepExecutors/set.ts —— 确定性变量赋值
+ * ------------------------------------------------------------
+ *  从 `runner.ts::runSteps` 的内联块搬出来。搬出来的收益不只是「runner 短了 40 行」：
+ *  它现在走**统一的提交流水线**（`stepPipeline.ts::commitStep`），于是
+ *  **`capture:` 自然生效了** —— 此前 set 从不调 `bindCapture`、checkpoint 里
+ *  记的是 `resolved` 而非 `collectCaptured(...)`，yaml 作者写了 `capture` 既不
+ *  报错也不生效，resume 时也回放不出来。典型的静默失效。
+ *
+ *  ⚠️ 两个必须保住的语义：
+ *   ① 写的是 `vars.setGlobal`（根帧）不是 `vars.set` —— set 步声明的是**工作流级**
+ *     变量，在循环体里写也必须活到循环之外。
+ *   ② 顶层值若是单一 `"${EXPR}"` 模板走 `interpolateTyped` **保留类型**
+ *     （布尔/数字/数组不字符串化成 "true"，下游条件不必写 `== true || == 'true'` 防御）；
+ *     多片段模板与嵌套结构走 `interpolateDeep`，行为不变。
+ * ============================================================
+ */
+
+import type { LoopEvent } from '../../../../src/plugin-sdk.js';
+import { interpolateDeep, interpolateTyped } from '../expressions.js';
+import type { StepDef, StepResult, VarStack } from '../types.js';
+
+export async function* execSetStep(
+  step: StepDef,
+  vars: VarStack,
+): AsyncGenerator<LoopEvent, StepResult, void> {
+  const missing: string[] = [];
+  const resolved: Record<string, unknown> = {};
+  for (const [k, v] of Object.entries(step.set ?? {})) {
+    resolved[k] =
+      typeof v === 'string'
+        ? interpolateTyped(v, vars, { onMissing: (e) => missing.push(e) })
+        : interpolateDeep(v, vars, { onMissing: (e) => missing.push(e) });
+  }
+  if (missing.length > 0) {
+    yield {
+      type: 'warning',
+      message: `step "${step.id}": 模板变量未定义：${[...new Set(missing)].map((m) => `\${${m}}`).join('、')}（裸名请用 inputs.<name> 或先 capture/set）`,
+    } as LoopEvent;
+  }
+  for (const [k, v] of Object.entries(resolved)) {
+    vars.setGlobal(k, v);
+  }
+  const summary = Object.entries(resolved)
+    .map(([k, v]) => `${k}=${String(v).slice(0, 40)}`)
+    .join(', ');
+  // raw 就是赋值表本身 —— 这样 `capture: { <变量名>: <别名> }` 能取到刚赋的值。
+  // replayVars 让 checkpoint 记下这些赋值：resume 跳过本步时变量仍能回放
+  //（set 步通常没有 capture:，只靠 collectCaptured 会记成 {}）。
+  return {
+    raw: { ...resolved },
+    replayVars: { ...resolved },
+    preview: `set: ${summary}`,
+  };
+}

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

@@ -15,11 +15,12 @@
  *  capture：{ text: var_name } / { result: var_name }
  * ============================================================
  */
-import { readdir, readFile } from 'node:fs/promises';
+import { readFile, readdir } from 'node:fs/promises';
 import { join } from 'node:path';
-import { getResourceSearchPaths } from '../../../../src/plugin-sdk.js';
+import { getResourceSearchPaths, } from '../../../../src/plugin-sdk.js';
 import { describeLlmFailure, describeMaxTurnsCutoff, effectiveGoalAnchor, runStepQuery, } from '../agentCommon.js';
 import { interpolate } from '../expressions.js';
+import { effectiveWorkflowCwd } from '../toolRuntime.js';
 function stripFrontmatter(content) {
     return content.replace(/^---\n[\s\S]*?\n---\n?/, '');
 }
@@ -53,9 +54,7 @@ async function findSkillFile(skillName, cwd) {
                 if (parseFrontmatterName(md) === skillName)
                     return skillFile;
             }
-            catch {
-                continue;
-            }
+            catch { }
         }
     }
     return null;
@@ -64,7 +63,7 @@ export async function* execSkillStep(step, vars, ctx) {
     if (!step.skill)
         throw new Error(`step ${step.id}: 缺少 skill 字段`);
     const skillName = interpolate(step.skill, vars);
-    const skillFile = await findSkillFile(skillName, ctx.cwd);
+    const skillFile = await findSkillFile(skillName, effectiveWorkflowCwd(ctx));
     if (!skillFile) {
         throw new Error(`step ${step.id}: 未找到 skill "${skillName}"（cwd/skills/ 与 packageRoot/skills/ 双源均未命中）`);
     }