minimal-agent 0.8.2 → 0.10.0

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

@@ -2,54 +2,172 @@
  * ============================================================
  *  plugins/workflow-runner/src/stepExecutors/agent.ts —— agent 步骤执行器
  * ------------------------------------------------------------
- *  执行 workflow 中 type: agent 的步骤：启动一个 miniReAct 子循环，
- *  用工具随机应变地完成开放性任务。
+ *  v0.9 重构：不再使用独立 miniReAct 子循环，而是委托主 TAOR 引擎
+ *  （runQuery / src/loop.ts）执行。这样做的好处：
  *
- *  与 llm 步骤的区别：
- *    - agent 有工具白名单（allowed_tools 过滤），可以 Read/Write/Grep/...
- *    - agent 跑多轮 miniReAct（maxTurns 上限），llm 只跑单轮 chat
- *    - agent 的产出经过验证闸门（interpretMiniReActResult），llm 直接透传
+ *    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 { interpolate } from '../expressions.js';
-import { runMiniReAct } from '../miniReAct.js';
-import { AGENT_OPENING, buildWorkflowAgentSystem, describeCaptureContract, interpretMiniReActResult, } from '../agentCommon.js';
+import { describeCaptureContract, describeLlmFailure, describeMaxTurnsCutoff, effectiveGoalAnchor, interpretMiniReActResult, runStepQuery, } from '../agentCommon.js';
+import { evalExpr, interpolate } from '../expressions.js';
+import { resolveWorkflowMultimodalOptions } from '../multimodal.js';
 /**
- * 执行一个 agent 步骤。
+ * 执行一个 agent 步骤：构造 step prompt → 委托 runQuery(TAOR) → 提取结果。
  *
- * 关键变化（Phase 2 重构）：
- *   buildWorkflowAgentSystem 现在是 async（因为需要扫描 skill/plugin 目录），
- *   agent 步骤的 system prompt 现在包含完整的：
- *     - 工具列表 + 使用规范
- *     - Skill 列表（含触发词）
- *     - Plugin 列表（含命令和描述）
- *   这解决了之前 workflow 模式下模型不知道有 pptx/pdf 等 skill 的问题。
+ * 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) {
-    // 工具白名单：allowed_tools 声明时按白名单过滤；未声明时默认全量（不限制）
-    const allTools = ctx.tools ?? [];
-    const tools = step.allowed_tools
-        ? allTools.filter((t) => step.allowed_tools.includes(t.name))
-        : allTools;
-    // ✅ Phase 2: 异步构建完整 system prompt（含 skill/plugin 列表）
-    const systemContent = await buildWorkflowAgentSystem(ctx.cwd, // 新增：传入 cwd 用于 skill/plugin 扫描
-    AGENT_OPENING, tools);
-    const userMsg = interpolate(step.agent ?? '', vars) +
-        describeCaptureContract(step) +
-        (step.input ? `\n\n上下文变量：${interpolate(step.input, vars)}` : '');
-    const messages = [
-        { role: 'system', content: systemContent },
-        { role: 'user', content: userMsg },
-    ];
-    const result = yield* runMiniReAct({
-        messages,
-        tools,
-        maxTurns: step.maxTurns ?? 12,
-        provider: ctx.provider,
-        signal: ctx.signal,
+    // 默认 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 outcome = interpretMiniReActResult(result, !!step.output_schema);
+    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}。`;
+}

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

@@ -1,18 +1,20 @@
 /**
  * ============================================================
- *  src/workflows/stepExecutors/assert.ts —— assert step 执行
+ *  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';
-export function execAssertStep(step, vars) {
+export function execAssertStep(step, vars, ctx) {
     if (typeof step.condition !== 'string') {
         throw new Error(`step ${step.id}: assert 缺少 condition`);
     }
     let ok;
     try {
-        // P2：表达式上下文直接 evalExpr（${} 由引擎原生处理），不再"先插值再 eval"。
         ok = Boolean(evalExpr(step.condition, vars));
     }
     catch (e) {
@@ -24,5 +26,16 @@ export function execAssertStep(step, 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/llm.js

@@ -1,132 +1,81 @@
 /**
  * ============================================================
- *  plugins/workflow-runner/src/stepExecutors/llm.ts —— llm step 执行
+ *  plugins/workflow-runner/src/stepExecutors/llm.ts —— llm 步骤执行器
  * ------------------------------------------------------------
- *  单轮 LLM 生成。关键设计：
- *    - tools: [] —— 不开任何工具（工具调用应该写成 tool: step）
- *    - 自带独立 system + user 两条消息，不污染主 history
- *    - AsyncGenerator：非 schema 模式把 text_delta 流式 yield 给 UI（答案是主角，
- *      消除 TUI"无声"），最终仍 return StepResult；schema 模式静默累积 JSON 不回显。
- *      reasoning 字段在这里忽略；只关心最终文本
+ *  v0.9 重构：不再使用独立 miniReAct 子循环或裸 chat()，而是委托主 TAOR 引擎
+ *  （runQuery / src/loop.ts）执行。
  *
- *  Phase 2 重构：
- *    - system prompt 现在追加 CapabilityHint（skill + plugin 轻量列表）
- *    - 即使 tools=[] 的 llm 步骤也知道有哪些 skill/plugin 可用，
- *      可以在输出文本中引用或建议用户后续使用（如 draft_plan 提到"建议用 /pptx 执行"）
+ *  与 agent 步的区别：
+ *    - llm 默认单轮（maxTurns=1），不下发工具
+ *    - 有 context_files 或 allowed_tools 时允许少量轮次读取文件后输出
+ *    - output_schema 嵌入 prompt 作为结构化约束
+ *    - 不经过 interpretMiniReActResult 验证闸门（直接信任 LLM 输出）
  *
  *  capture：
- *    - `{ text: var_name }` 绑生成文本（无 output_schema 时）
- *    - `{ result: var_name }` 同义
- *    - `{ <field>: var_name }` 当 output_schema 命中时按 raw 上的字段名取
- *
- *  ADR-05: 当 step.output_schema 存在 → 走 provider-native structured output：
- *    - 通过 chat() 的 responseFormat 参数下发 JSON Schema
- *    - 收到的文本必须解析为 JSON 对象，整对象作为 raw 暴露给 capture
- *    - system prompt 切换为严格 JSON 模式，禁止 markdown 代码块包裹
+ *    - `{ text: var_name }` 绑生成文本
+ *    - `{ <field>: var_name }` 当 output_schema 存在时按 JSON 字段取值
  * ============================================================
  */
-import { ALL_TOOLS, chat, } from '../../../../src/plugin-sdk.js';
+import { describeLlmFailure, describeMaxTurnsCutoff, effectiveGoalAnchor, runStepQuery, } from '../agentCommon.js';
 import { interpolate } from '../expressions.js';
 import { extractJsonPayload } from '../jsonPayload.js';
-import { runMiniReAct } from '../miniReAct.js';
-import { assembleCapabilityHint } from '../../../../src/prompts/promptAssembly.js';
-const LLM_STEP_SYSTEM_PLAIN = '你正在被一个 workflow 调用。只输出本步骤要求的内容本身，不要寒暄、不要列要求复述、不要工具调用语法。';
-const LLM_STEP_SYSTEM_SCHEMA = `你正在被一个 workflow 调用。
-要求：
-1. 严格按指定 JSON Schema 输出有效 JSON，**不要 markdown 代码块包裹**（不要 \`\`\`json 也不要 \`\`\`）
-2. 不要寒暄、不要解释、不要额外字段
-3. 字段缺失或类型不符会导致 workflow 失败
-4. 字符串内特殊字符必须正确转义（双引号 \\", 反斜杠 \\\\, 换行 \\n）`;
-const LLM_STEP_SYSTEM_WITH_TOOLS = `你正在被一个 workflow 调用。你被授予了有限的工具（通常是 Read）以查询提供的上下文文件。
-
-工作流程：
-1. 先用 Read 工具读取你需要的文件（按需读取，**不要全部读完再思考**——大文件分段读、按 hint 选读）
-2. 基于读到的内容生成最终回答
-3. 不要寒暄、不要复述要求、不要解释你的推理过程
-4. 完成后**不要**再调用工具，直接输出最终回答
-
-如果 workflow 要求结构化输出，请在最终回答里严格遵循 JSON Schema（无 markdown 代码块包裹）。`;
+import { resolveWorkflowMultimodalOptions } from '../multimodal.js';
 export async function* execLlmStep(step, vars, ctx) {
     if (typeof step.llm !== 'string')
         throw new Error(`step ${step.id}: 缺少 llm 字段`);
-    const prompt = interpolate(step.llm, vars);
-    // ===== ADR-05 阶段 4: context_files → miniReAct 子循环 =====
+    // 未定义变量插值可见化（静默空串是下游 prompt 留白的病根）
+    const missing = [];
+    const iopts = { onMissing: (e) => 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)}${f.hint ? ` — ${f.hint}` : ''}`)
+            .map((f) => `- ${interpolate(f.path, vars, iopts)}${f.hint ? ` — ${f.hint}` : ''}`)
             .join('\n');
-        const augmented = `${prompt}\n\n**以下文件可用，请用 Read 工具按需读取**：\n${fileList}`;
-        const allowedNames = step.allowed_tools ?? ['Read'];
-        const allowedTools = ALL_TOOLS.filter((t) => allowedNames.includes(t.name));
-        if (allowedTools.length === 0) {
-            throw new Error(`step ${step.id}: context_files 启用但 allowed_tools=${JSON.stringify(allowedNames)} 没有匹配的可用工具`);
-        }
-        return yield* runMiniReAct({
-            messages: [
-                { role: 'system', content: LLM_STEP_SYSTEM_WITH_TOOLS },
-                { role: 'user', content: augmented },
-            ],
-            tools: allowedTools,
-            output_schema: step.output_schema,
-            provider: ctx.provider,
-            signal: ctx.signal,
-            maxTurns: step.maxTurns ?? 10,
-        });
+        fullPrompt = `${prompt}\n\n**以下上下文文件可用，请用 Read 工具按需读取**：\n${fileList}`;
     }
-    // ===== END NEW =====
-    const useSchema = step.output_schema !== undefined;
-    // schema 模式：把 schema 直接写进 system prompt。这样无论 provider 是否支持
-    // response_format.json_schema（火山 GLM 等不支持、会被 client.ts 退化掉 response_format），
-    // 模型都知道确切字段名与结构 —— 退化路径也能产出正确形状的 JSON，而非瞎猜字段。
-    const schemaHint = useSchema
-        ? `\n\n最终只输出匹配以下 JSON Schema 的 JSON 对象本身（不要解释、不要 markdown 代码块）：\n${JSON.stringify(step.output_schema)}`
+    // output_schema 约束嵌入 prompt
+    const schemaHint = step.output_schema
+        ? `\n\n【结构化输出约束】请严格按照以下 JSON Schema 输出有效 JSON 对象本身（不要 markdown 代码块包裹）：\n${JSON.stringify(step.output_schema, null, 2)}`
         : '';
-    // ✅ Phase 2: 追加 CapabilityHint —— 让 llm 步骤知道有哪些 skill/plugin 可用
-    // 即使 tools=[] 不能执行工具，模型也能在输出中引用或建议用户后续使用
-    const capabilityHint = await assembleCapabilityHint(ctx.cwd);
-    const baseSystem = (useSchema ? LLM_STEP_SYSTEM_SCHEMA : LLM_STEP_SYSTEM_PLAIN) + schemaHint;
-    const messages = [
-        {
-            role: 'system',
-            content: baseSystem + capabilityHint,
-        },
-        { role: 'user', content: prompt },
-    ];
-    const responseFormat = useSchema
-        ? {
-            type: 'json_schema',
-            json_schema: {
-                name: `${step.id}_output`,
-                schema: step.output_schema,
-                strict: true,
-            },
-        }
-        : undefined;
-    let text = '';
-    for await (const ev of chat({
-        provider: ctx.provider,
-        messages,
-        tools: [],
-        responseFormat,
-        signal: ctx.signal,
-    })) {
-        if (ev.type === 'text_delta') {
-            text += ev.delta;
-            // 非 schema 模式：把答案流式 yield 给 UI（答案是主角，消除"无声"）。
-            // schema 模式输出是原始 JSON，不当"答案文本"回显，避免屏幕闪 JSON。
-            if (!useSchema)
-                yield { type: 'text', delta: ev.delta };
-        }
-        if (ev.type === 'done' && ev.stopReason === 'aborted') {
-            throw new Error('用户中断');
-        }
+    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));
     }
-    const trimmed = text.trim();
-    if (useSchema) {
-        // strict structured output：解析 JSON 后整个对象作为 raw。
-        // 思考型模型即便在 strict 下仍会把 think…</think 写进 content（见 jsonPayload.ts
-        // 头注与 src/llm/client.ts:200），故先剥思维链/前后散文再 parse；报错仍带原文便于排查。
-        const payload = extractJsonPayload(text);
+    // 结构化输出模式：解析 JSON
+    if (step.output_schema) {
+        const payload = extractJsonPayload(trimmed);
         let parsed;
         try {
             parsed = JSON.parse(payload);
@@ -142,7 +91,7 @@ export async function* execLlmStep(step, vars, ctx) {
             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/skill.js

@@ -1,28 +1,24 @@
-// NOTE: output_schema 不支持 skill 节点——loader 现已直接拒绝 skill+output_schema 组合
-// （见 loader.ts validateSteps，P3 修复：静默 no-op 改为加载期报错）。
-// 仅 llm 节点支持 provider-native structured output；vote 通过 runVoter 调 execLlmStep（llm 虚拟步骤）。
 /**
  * ============================================================
- *  plugins/workflow-runner/src/stepExecutors/skill.ts —— skill step 执行
+ *  plugins/workflow-runner/src/stepExecutors/skill.ts —— skill 步骤执行器
  * ------------------------------------------------------------
- *  把一个具名 skill（skills/<name>/SKILL.md）当作"迷你 ReAct 子循环"
- *  跑一次：复用 src/loop.ts::runQuery，让模型在子 history 内 T-A-O-R。
+ *  v0.9 重构：不再使用独立 subHistory 隔离子循环，而是委托主 TAOR 引擎
+ *  （runQuery / src/loop.ts）在共享 ctx.history 上执行。
  *
  *  实现要点：
- *    - 双源查找：cwd/skills/<name>/SKILL.md 优先，packageRoot/skills/ fallback；
- *      支持按目录名 or 按 frontmatter::name 匹配
- *    - 剥掉 frontmatter，body 作 system 指令；step.input 插值后作为 user
- *    - 子 history 与外层 ctx.history 隔离，避免污染主对话
- *    - 流式转发：runQuery yield 的事件直接 yield 出去（让 UI 看到子循环进度）
- *    - 收集 text 事件累计为 raw.text，供 capture 绑变量使用
- *    - maxTurns 可在 step 里覆盖，默认走 runQuery 自带（50）
+ *    - 双源查找：cwd/skills/<name>/SKILL.md 优先，packageRoot/skills/ fallback
+ *    - SKILL.md body 作为用户提示的一部分（系统提示词已在 history[0]）
+ *    - 执行结果直接写入共享 ctx.history，上下文自然积累
+ *    - 流式转发：runQuery yield 的事件直接透传给 UI
+ *    - maxTurns 可在 step 里覆盖（默认 25）
  *
  *  capture：{ text: var_name } / { result: var_name }
  * ============================================================
  */
 import { readdir, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { getResourceSearchPaths, runQuery, } 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';
 function stripFrontmatter(content) {
     return content.replace(/^---\n[\s\S]*?\n---\n?/, '');
@@ -36,8 +32,8 @@ function parseFrontmatterName(content) {
         return null;
     return nm[1].trim().replace(/^["']|["']$/g, '');
 }
-async function findSkillFile(skillName) {
-    const roots = getResourceSearchPaths('skills', import.meta.url);
+async function findSkillFile(skillName, cwd) {
+    const roots = getResourceSearchPaths('skills', import.meta.url, cwd);
     for (const root of roots) {
         let entries;
         try {
@@ -58,7 +54,7 @@ async function findSkillFile(skillName) {
                     return skillFile;
             }
             catch {
-                // 该子目录无 SKILL.md，跳过
+                continue;
             }
         }
     }
@@ -68,43 +64,47 @@ 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);
+    const skillFile = await findSkillFile(skillName, ctx.cwd);
     if (!skillFile) {
         throw new Error(`step ${step.id}: 未找到 skill "${skillName}"（cwd/skills/ 与 packageRoot/skills/ 双源均未命中）`);
     }
     const md = await readFile(skillFile, 'utf8');
     const body = stripFrontmatter(md).trim();
+    // 构造用户提示：skill 指令 + 步骤 input
+    // 系统提示词已在 history[0] 中（含完整 skill 列表和描述），
+    // 这里不需要再拼 system message——把 SKILL.md body 作为操作指令即可
+    const missing = [];
     const userInput = step.input
-        ? interpolate(step.input, vars)
-        : `请按 SKILL "${skillName}" 的指示完成任务。`;
-    const subHistory = [
-        {
-            role: 'system',
-            content: `下面是要遵循的 SKILL 指示（来源：${skillFile}）：\n\n${body}`,
-        },
-    ];
-    let text = '';
-    for await (const ev of runQuery(userInput, {
-        provider: ctx.provider,
-        history: subHistory,
-        signal: ctx.signal,
-        maxTurns: step.maxTurns,
-    })) {
-        if (ev.type === 'text')
-            text += ev.delta;
-        if (ev.type === 'interrupted')
-            throw new Error('用户中断');
-        if (ev.type === 'error')
-            throw new Error(ev.error);
-        // 子 skill 内部那次 runQuery 的 turn_done 是它自己的终结标记，不是整个 workflow 的终结。
-        // 不外泄——否则把 turn_done 当终结的消费者（-p --output-format json / gateway broker）
-        // 会在 workflow 中途（如 critic 步之后、verify 步之前）误判结束、漏掉后续步骤。
-        // workflow 的对外收口由 index.ts::runWorkflowFromCommand 末尾统一补发。
-        if (ev.type === 'turn_done')
-            continue;
-        yield ev;
+        ? interpolate(step.input, vars, { onMissing: (e) => missing.push(e) })
+        : `请按以下 SKILL "${skillName}" 的指示完成任务。`;
+    const fullPrompt = `【执行 Skill：${skillName}】\n\n${body}\n\n---\n\n当前任务：\n${userInput}`;
+    // 通用目标锚定（原始目标 + 补充要求）：确保 skill 执行时也不偏离
+    const anchor = effectiveGoalAnchor(ctx);
+    const effectivePrompt = anchor ? `${anchor}\n\n${fullPrompt}` : fullPrompt;
+    const maxTurns = step.maxTurns ?? 25;
+    if (missing.length > 0) {
+        yield {
+            type: 'warning',
+            message: `step "${step.id}": 模板变量未定义，已按空串插值：${[...new Set(missing)].map((m) => `\${${m}}`).join('、')}（裸名请用 inputs.<name> 或先 capture/set）`,
+        };
+    }
+    // 委托 TAOR 引擎在共享 history 上执行（共享消费层 runStepQuery）。
+    // suppressTurnDone：turn_done 是 runQuery 单次调用的终结标记，不是 workflow 终结，
+    // 外泄会导致 gateway broker / -p json 模式误判 workflow 中途结束。
+    const { rawText, aborted, sawLlmError, sawMaxTurns, llmErrorDetail } = yield* runStepQuery(effectivePrompt, step, ctx, {
+        maxTurns,
+        suppressTurnDone: true,
+    });
+    const trimmed = rawText.trim();
+    // P0-1：LLM 失败（超时/网络错）且本步无任何产出 → 抛异常，触发 runner 的 max_retries 重跑。
+    // 用户中断（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));
     }
-    const trimmed = text.trim();
     return {
         raw: { text: trimmed, result: trimmed },
         preview: trimmed.length > 200 ? `${trimmed.slice(0, 200)}...` : trimmed,