minimal-agent 0.13.0 → 0.14.0

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

@@ -1,38 +0,0 @@
-import { isAbsolute, resolve } from 'node:path';
-import { interpolate } from './expressions.js';
-import { effectiveWorkflowCwd } from './toolRuntime.js';
-export function resolveWorkflowMultimodalOptions(step, vars, ctx, onMissing) {
-    const imageDetail = step.image_detail;
-    const imageMaxLongSidePixel = step.image_max_long_side_pixel;
-    const imageInputs = (step.images ?? []).map((item) => {
-        if (typeof item === 'string') {
-            return {
-                source: resolveWorkflowImageSource(interpolate(item, vars, { onMissing }), ctx),
-                detail: imageDetail,
-                maxLongSidePixel: imageMaxLongSidePixel,
-            };
-        }
-        return {
-            source: resolveWorkflowImageSource(interpolate(item.source, vars, { onMissing }), ctx),
-            detail: item.detail ?? imageDetail,
-            maxLongSidePixel: item.max_long_side_pixel ?? imageMaxLongSidePixel,
-        };
-    });
-    return {
-        imageInputs: imageInputs.length > 0 ? imageInputs : undefined,
-        parseInlineImages: step.parse_inline_images,
-        imageDetail,
-        imageMaxLongSidePixel,
-    };
-}
-function resolveWorkflowImageSource(source, ctx) {
-    const clean = source.trim();
-    if (/^https?:\/\//i.test(clean) ||
-        /^data:image\//i.test(clean) ||
-        clean.startsWith('file://') ||
-        clean.startsWith('~/') ||
-        isAbsolute(clean)) {
-        return clean;
-    }
-    return resolve(effectiveWorkflowCwd(ctx), clean);
-}

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

@@ -1,64 +0,0 @@
-import { isAbsolute, resolve } from 'node:path';
-
-import type { ImageDetail, ImageInputSpec } from '../../../src/plugin-sdk.js';
-import { interpolate } from './expressions.js';
-import { effectiveWorkflowCwd } from './toolRuntime.js';
-import type { RunContext, StepDef, VarStack } from './types.js';
-
-export interface WorkflowMultimodalOptions {
-  imageInputs?: ImageInputSpec[];
-  parseInlineImages?: boolean;
-  imageDetail?: ImageDetail;
-  imageMaxLongSidePixel?: number;
-}
-
-export function resolveWorkflowMultimodalOptions(
-  step: StepDef,
-  vars: VarStack,
-  ctx: RunContext,
-  onMissing?: (expr: string) => void,
-): WorkflowMultimodalOptions {
-  const imageDetail = step.image_detail;
-  const imageMaxLongSidePixel = step.image_max_long_side_pixel;
-  const imageInputs = (step.images ?? []).map((item) => {
-    if (typeof item === 'string') {
-      return {
-        source: resolveWorkflowImageSource(
-          interpolate(item, vars, { onMissing }),
-          ctx,
-        ),
-        detail: imageDetail,
-        maxLongSidePixel: imageMaxLongSidePixel,
-      };
-    }
-    return {
-      source: resolveWorkflowImageSource(
-        interpolate(item.source, vars, { onMissing }),
-        ctx,
-      ),
-      detail: item.detail ?? imageDetail,
-      maxLongSidePixel: item.max_long_side_pixel ?? imageMaxLongSidePixel,
-    };
-  });
-
-  return {
-    imageInputs: imageInputs.length > 0 ? imageInputs : undefined,
-    parseInlineImages: step.parse_inline_images,
-    imageDetail,
-    imageMaxLongSidePixel,
-  };
-}
-
-function resolveWorkflowImageSource(source: string, ctx: RunContext): string {
-  const clean = source.trim();
-  if (
-    /^https?:\/\//i.test(clean) ||
-    /^data:image\//i.test(clean) ||
-    clean.startsWith('file://') ||
-    clean.startsWith('~/') ||
-    isAbsolute(clean)
-  ) {
-    return clean;
-  }
-  return resolve(effectiveWorkflowCwd(ctx), clean);
-}

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

@@ -1,126 +0,0 @@
-/**
- * ============================================================
- *  plugins/workflow-runner/src/recovery.ts —— 节点失败的自适应恢复
- * ------------------------------------------------------------
- *  「确定性工作流 × 随机应变 agent」的结合点（onError:'recover'）。
- *
- *  传统 DAG 的脆点：某节点抛错 → 整条 halt（或 onError:'continue' 盲跳，下游
- *  capture 拿 undefined 静默级联错）。当节点声明 onError:'recover' 时，runner
- *  不立刻 halt，而是调本模块起一个**有界恢复 agent**（委托 runQuery/TAOR），
- *  喂给它「工作流总目标 + 失败节点的意图 + 错误信息 + 当前已知变量 + 下游 capture 契约」，
- *  让它**随机应变去达成该节点本来要的结果**（换路径 / 换命令 / 先读后写…）。
- *
- *  v0.9 重构：不再使用独立 miniReAct 子循环，而是委托主 TAOR 引擎（runQuery）
- *  在共享 ctx.history 上执行。恢复过程也写入共享上下文——后续对话能看到"某步失败后
- *  如何被自动修复"，增强可解释性。
- *
- *  —— 共享大脑 ——
- *  恢复 agent 与正常 agent/llm/skill 步本质同构：都通过 runQuery(TAOR) 执行。
- *  本模块只构造「救火」角色提示词，跑完后交给 interpretMiniReActResult 判定
- *  「真救回 / 放弃」。返回 AgentOutcome：
- *    - { ok:true, value }  —— runner 用同一个 step.capture 绑定后继续 happy path
- *    - { ok:false, reason } —— runner 带原因 honest halt
- * ============================================================
- */
-import { describeCaptureContract, effectiveGoalAnchor, interpretMiniReActResult, runStepQuery, truncate, } from './agentCommon.js';
-import { interpolate, interpolateDeep } from './expressions.js';
-// RECOVER_OPENING 作为用户消息的一部分（系统提示词已在 history[0] 中）
-const RECOVER_OPENING = `你是一名资深的自动化工程师 / SRE，被一个确定性工作流临时调来「救火」。
-工作流里一个原本写死的步骤刚刚执行失败了，现在交给你随机应变——先看错误信息诊断根因，再想办法真正达成这个步骤**本来要的结果**（关注它要的结果，别拘泥它原先怎么写）。`;
-/** 描述失败节点「本来要干什么」，喂给恢复 agent 作为意图说明。 */
-function describeStepIntent(step, vars) {
-    if (step.tool) {
-        const args = interpolateDeep(step.args ?? {}, vars);
-        return `调用工具 ${step.tool}，参数：${JSON.stringify(args)}`;
-    }
-    if (step.agent) {
-        return `自主完成这个开放任务：${interpolate(step.agent, vars)}`;
-    }
-    if (step.llm) {
-        return `用 LLM 生成内容，提示词：${interpolate(step.llm, vars)}`;
-    }
-    if (step.skill) {
-        const input = step.input ? interpolate(step.input, vars) : '(无显式输入)';
-        return `执行 skill「${interpolate(step.skill, vars)}」，输入：${input}`;
-    }
-    if (step.type === 'assert') {
-        return `让这个断言成立：${step.condition}`;
-    }
-    return `完成步骤 ${step.id}`;
-}
-/**
- * 尝试自适应恢复一个失败的动作 step。
- *   - 救回 → { ok:true, value }（value.raw 已 normalize，可被原 step.capture 绑定）
- *   - 放弃 / 不可信 / 子循环抛错（含用户中断）→ { ok:false, reason }
- */
-export async function* runRecovery(step, vars, ctx, errorMsg) {
-    const intent = describeStepIntent(step, vars);
-    const knownVars = truncate(JSON.stringify(vars.snapshot()), 1500);
-    const goalLine = ctx.goal ? `工作流总目标：${ctx.goal}\n\n` : '';
-    const captureLine = describeCaptureContract(step);
-    const hintLine = step.recover_hint
-        ? `\n\n作者给恢复的提示：${interpolate(step.recover_hint, vars)}`
-        : '';
-    // 构造恢复 prompt（作为 user message push 进共享 history）
-    const recoverPrompt = `${RECOVER_OPENING}\n\n` +
-        `${goalLine}` +
-        `失败的步骤（id=${step.id}）本来要做的事：\n${intent}\n\n` +
-        `它失败时的错误：\n${truncate(errorMsg, 800)}\n\n` +
-        `当前已知的变量（JSON）：\n${knownVars}` +
-        `${captureLine}${hintLine}\n\n` +
-        `请随机应变，把这一步要的结果做出来；做不成就按约定输出放弃标记。`;
-    // output_schema 约束嵌入 prompt
-    const schemaHint = step.output_schema
-        ? `\n\n【结构化输出约束】请严格按照以下 JSON Schema 输出结果：\n${JSON.stringify(step.output_schema, null, 2)}`
-        : '';
-    // 通用目标锚定（同 agent/llm/skill 步）：恢复 agent 也要看到用户原始目标
-    // 与补充要求，不能只有 def.description 的"工作流总目标"（E10）。
-    const anchor = effectiveGoalAnchor(ctx);
-    const fullPrompt = anchor
-        ? `${anchor}\n\n${recoverPrompt}${schemaHint}`
-        : recoverPrompt + schemaHint;
-    try {
-        // 委托 TAOR 引擎执行（共享消费层 runStepQuery）——事件透传给 UI（显示恢复进度）。
-        // 注意剥掉 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 前已用尽）；只是归因更诚实。
-        if (!rawText.trim() && sawLlmError) {
-            return {
-                ok: false,
-                reason: `LLM 调用失败且无产出${llmErrorDetail ? `—— ${truncate(llmErrorDetail, 300)}` : ''}`,
-            };
-        }
-        // 恢复 agent 也撞 maxTurns 截断 → 截断产出不可信，诚实「未救回」
-        if (sawMaxTurns) {
-            return {
-                ok: false,
-                reason: `恢复 agent 达到最大轮数 ${step.maxTurns ?? 25} 被截断，产出不可信（未救回）`,
-            };
-        }
-        const stepResult = {
-            raw: { text: rawText, result: rawText },
-            preview: rawText.length > 200 ? `${rawText.slice(0, 200)}...` : rawText,
-        };
-        const outcome = interpretMiniReActResult(stepResult, !!step.output_schema);
-        if (!outcome.ok)
-            return outcome;
-        // 救回：preview 加 recovered: 前缀（runner 的 step_end output 用），raw 原样。
-        return {
-            ok: true,
-            value: { raw: outcome.value.raw, preview: `recovered: ${outcome.value.preview}` },
-        };
-    }
-    catch (e) {
-        // runStepQuery 抛错（编程性异常 / 中断竞态）→ 恢复失败。
-        return { ok: false, reason: e.message ?? String(e) };
-    }
-}

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

@@ -1,156 +0,0 @@
-/**
- * ============================================================
- *  plugins/workflow-runner/src/recovery.ts —— 节点失败的自适应恢复
- * ------------------------------------------------------------
- *  「确定性工作流 × 随机应变 agent」的结合点（onError:'recover'）。
- *
- *  传统 DAG 的脆点：某节点抛错 → 整条 halt（或 onError:'continue' 盲跳，下游
- *  capture 拿 undefined 静默级联错）。当节点声明 onError:'recover' 时，runner
- *  不立刻 halt，而是调本模块起一个**有界恢复 agent**（委托 runQuery/TAOR），
- *  喂给它「工作流总目标 + 失败节点的意图 + 错误信息 + 当前已知变量 + 下游 capture 契约」，
- *  让它**随机应变去达成该节点本来要的结果**（换路径 / 换命令 / 先读后写…）。
- *
- *  v0.9 重构：不再使用独立 miniReAct 子循环，而是委托主 TAOR 引擎（runQuery）
- *  在共享 ctx.history 上执行。恢复过程也写入共享上下文——后续对话能看到"某步失败后
- *  如何被自动修复"，增强可解释性。
- *
- *  —— 共享大脑 ——
- *  恢复 agent 与正常 agent/llm/skill 步本质同构：都通过 runQuery(TAOR) 执行。
- *  本模块只构造「救火」角色提示词，跑完后交给 interpretMiniReActResult 判定
- *  「真救回 / 放弃」。返回 AgentOutcome：
- *    - { ok:true, value }  —— runner 用同一个 step.capture 绑定后继续 happy path
- *    - { ok:false, reason } —— runner 带原因 honest halt
- * ============================================================
- */
-
-import type { LoopEvent } from '../../../src/plugin-sdk.js';
-import {
-  type AgentOutcome,
-  describeCaptureContract,
-  effectiveGoalAnchor,
-  interpretMiniReActResult,
-  runStepQuery,
-  truncate,
-} from './agentCommon.js';
-import { interpolate, interpolateDeep } from './expressions.js';
-import type { RunContext, StepDef, VarStack } from './types.js';
-
-// RECOVER_OPENING 作为用户消息的一部分（系统提示词已在 history[0] 中）
-const RECOVER_OPENING = `你是一名资深的自动化工程师 / SRE，被一个确定性工作流临时调来「救火」。
-工作流里一个原本写死的步骤刚刚执行失败了，现在交给你随机应变——先看错误信息诊断根因，再想办法真正达成这个步骤**本来要的结果**（关注它要的结果，别拘泥它原先怎么写）。`;
-
-/** 描述失败节点「本来要干什么」，喂给恢复 agent 作为意图说明。 */
-function describeStepIntent(step: StepDef, vars: VarStack): string {
-  if (step.tool) {
-    const args = interpolateDeep(step.args ?? {}, vars);
-    return `调用工具 ${step.tool}，参数：${JSON.stringify(args)}`;
-  }
-  if (step.agent) {
-    return `自主完成这个开放任务：${interpolate(step.agent, vars)}`;
-  }
-  if (step.llm) {
-    return `用 LLM 生成内容，提示词：${interpolate(step.llm, vars)}`;
-  }
-  if (step.skill) {
-    const input = step.input ? interpolate(step.input, vars) : '(无显式输入)';
-    return `执行 skill「${interpolate(step.skill, vars)}」，输入：${input}`;
-  }
-  if (step.type === 'assert') {
-    return `让这个断言成立：${step.condition}`;
-  }
-  return `完成步骤 ${step.id}`;
-}
-
-/**
- * 尝试自适应恢复一个失败的动作 step。
- *   - 救回 → { ok:true, value }（value.raw 已 normalize，可被原 step.capture 绑定）
- *   - 放弃 / 不可信 / 子循环抛错（含用户中断）→ { ok:false, reason }
- */
-export async function* runRecovery(
-  step: StepDef,
-  vars: VarStack,
-  ctx: RunContext,
-  errorMsg: string,
-): AsyncGenerator<LoopEvent, AgentOutcome, void> {
-  const intent = describeStepIntent(step, vars);
-  const knownVars = truncate(JSON.stringify(vars.snapshot()), 1500);
-  const goalLine = ctx.goal ? `工作流总目标：${ctx.goal}\n\n` : '';
-  const captureLine = describeCaptureContract(step);
-  const hintLine = step.recover_hint
-    ? `\n\n作者给恢复的提示：${interpolate(step.recover_hint, vars)}`
-    : '';
-
-  // 构造恢复 prompt（作为 user message push 进共享 history）
-  const recoverPrompt =
-    `${RECOVER_OPENING}\n\n` +
-    `${goalLine}` +
-    `失败的步骤（id=${step.id}）本来要做的事：\n${intent}\n\n` +
-    `它失败时的错误：\n${truncate(errorMsg, 800)}\n\n` +
-    `当前已知的变量（JSON）：\n${knownVars}` +
-    `${captureLine}${hintLine}\n\n` +
-    `请随机应变，把这一步要的结果做出来；做不成就按约定输出放弃标记。`;
-
-  // output_schema 约束嵌入 prompt
-  const schemaHint = step.output_schema
-    ? `\n\n【结构化输出约束】请严格按照以下 JSON Schema 输出结果：\n${JSON.stringify(step.output_schema, null, 2)}`
-    : '';
-
-  // 通用目标锚定（同 agent/llm/skill 步）：恢复 agent 也要看到用户原始目标
-  // 与补充要求，不能只有 def.description 的"工作流总目标"（E10）。
-  const anchor = effectiveGoalAnchor(ctx);
-  const fullPrompt = anchor
-    ? `${anchor}\n\n${recoverPrompt}${schemaHint}`
-    : recoverPrompt + schemaHint;
-
-  try {
-    // 委托 TAOR 引擎执行（共享消费层 runStepQuery）——事件透传给 UI（显示恢复进度）。
-    // 注意剥掉 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 前已用尽）；只是归因更诚实。
-    if (!rawText.trim() && sawLlmError) {
-      return {
-        ok: false,
-        reason: `LLM 调用失败且无产出${llmErrorDetail ? `—— ${truncate(llmErrorDetail, 300)}` : ''}`,
-      };
-    }
-    // 恢复 agent 也撞 maxTurns 截断 → 截断产出不可信，诚实「未救回」
-    if (sawMaxTurns) {
-      return {
-        ok: false,
-        reason: `恢复 agent 达到最大轮数 ${step.maxTurns ?? 25} 被截断，产出不可信（未救回）`,
-      };
-    }
-
-    const stepResult: import('./types.js').StepResult = {
-      raw: { text: rawText, result: rawText },
-      preview: rawText.length > 200 ? `${rawText.slice(0, 200)}...` : rawText,
-    };
-    const outcome = interpretMiniReActResult(stepResult, !!step.output_schema);
-    if (!outcome.ok) return outcome;
-
-    // 救回：preview 加 recovered: 前缀（runner 的 step_end output 用），raw 原样。
-    return {
-      ok: true,
-      value: { raw: outcome.value.raw, preview: `recovered: ${outcome.value.preview}` },
-    };
-  } catch (e) {
-    // runStepQuery 抛错（编程性异常 / 中断竞态）→ 恢复失败。
-    return { ok: false, reason: (e as Error).message ?? String(e) };
-  }
-}

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

@@ -1,173 +0,0 @@
-/**
- * ============================================================
- *  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 { describeCaptureContract, describeLlmFailure, describeMaxTurnsCutoff, effectiveGoalAnchor, interpretMiniReActResult, runStepQuery, } from '../agentCommon.js';
-import { evalExpr, interpolate } from '../expressions.js';
-import { resolveWorkflowMultimodalOptions } from '../multimodal.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, vars, ctx) {
-    // 默认 25（与 skill 步 skill.ts 对齐）。agent 步本就是「开放多工具任务」执行器，
-    // 弱模型常一轮只调一个工具（Read/Grep/Glob 各占一轮），旧默认 12 对探索类步骤
-    // （如 plan.yaml stage1_research）太紧——12 轮还没收集完就撞顶截断、误判失败。
-    // 这是安全阀不是性能阀；要更紧的步显式写小值即可。
-    const maxTurns = step.maxTurns ?? 25;
-    // 未定义变量插值可见化（裸 ${goal} 这类拼写/命名空间错的病根，静默空串会坑死下游）
-    const missing = [];
-    const iopts = { onMissing: (e) => 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 = {
-        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, vars) {
-    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.message}`);
-    }
-}
-function doneWhenSatisfiedResult(step) {
-    const text = `完成条件已满足：${step.done_when}`;
-    return { raw: { text, result: text, content: text }, preview: text };
-}
-function resultIfTextLooksDeliverable(step, text) {
-    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;
-}
-function describeAttemptForDoneWhen(outcome) {
-    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}。`;
-}