minimal-agent 0.8.1 → 0.9.0

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

@@ -11,7 +11,7 @@
  *
  *  支持的 step kind（loader 已校验）：
  *    - tool / llm / assert            —— 原子动作（execXxxStep 返回 StepResult）
- *    - agent / skill                  —— 有界 TAOR：miniReAct(agent) / 外部 SKILL.md(skill)；
+ *    - agent / skill                  —— 有界 TAOR：runQuery(agent) / runQuery(skill)；
  *                                        透传子事件（stage_change/text/reasoning/tool_*）
  *    - branch / loop / pause          —— 控制流，直接在 runSteps 内处理（不走 executor）
  *    - parallel / vote                —— 并发 / 投票门，也在 runSteps 内处理
@@ -41,7 +41,49 @@ import { WorkflowState } from './workflowState.js';
  * （-p 非交互模式另由 src/cli/print.ts 把通用 warning 事件落 stderr。）
  */
 const WF_PLUGIN_ID = 'workflow-runner';
+/**
+ * 从工作流 inputs 定义 + 实际值中提取用户的原始目标，
+ * 构建紧凑的目标锚定字符串。
+ *
+ * 提取策略：
+ *   1. 优先取名为 "goal" 的输入（plan.yaml / ralph-loop.yaml 等通用约定）
+ *   2. 其次取第一个 required: true 的 string 类型输入
+ *   3. 都没有 → 返回空字符串（executor 自动跳过）
+ *
+ * 锚定字符串格式紧凑（~60-150 字符），注入每步 prompt 前置，
+ * 确保 LLM 在任何步骤都能"看到"用户原始目标，避免长上下文稀释。
+ */
+function buildGoalAnchor(inputDefs, inputValues) {
+    let goalValue;
+    // 策略 1：优先 "goal"
+    const goalInput = inputDefs.find((d) => d.name === 'goal' && d.type === 'string');
+    if (goalInput) {
+        const v = inputValues[goalInput.name];
+        if (typeof v === 'string' && v.trim()) {
+            goalValue = v.trim();
+        }
+    }
+    // 策略 2：fallback 第一个 required string
+    if (!goalValue) {
+        const firstRequired = inputDefs.find((d) => d.required && d.type === 'string');
+        if (firstRequired) {
+            const v = inputValues[firstRequired.name];
+            if (typeof v === 'string' && v.trim()) {
+                goalValue = v.trim();
+            }
+        }
+    }
+    if (!goalValue)
+        return '';
+    // 截断过长目标（>200 字符时保留首尾，中间用 … 连接）
+    const display = goalValue.length > 200
+        ? `${goalValue.slice(0, 120)}…${goalValue.slice(-60)}`
+        : goalValue;
+    return `> 🎯 用户原始目标：${display}\n> ⚠️ 所有操作必须直接回应此目标，不可偏离或遗忘。`;
+}
 function stepKind(step) {
+    if (step.type === 'break')
+        return 'break';
     if (step.type)
         return step.type;
     if (step.tool)
@@ -78,7 +120,7 @@ function bindCapture(captureMap, result, vars) {
  */
 async function* dispatchActionStep(step, vars, ctx) {
     if (step.type === 'assert')
-        return execAssertStep(step, vars);
+        return execAssertStep(step, vars, ctx);
     if (step.type === 'verify')
         return await execVerifyStep(step, vars);
     if (step.tool)
@@ -182,8 +224,63 @@ async function* runSteps(steps, vars, ctx, state) {
             };
             continue;
         }
-        // ---------- 控制流：loop ----------
+        // ---------- 控制流：loop（for-each 或 while） ----------
         if (step.type === 'loop') {
+            const isWhileMode = step.over === undefined;
+            const maxIter = step.max_iterations ?? 200; // while 模式安全上限
+            const useFreshContext = step.fresh_context === true;
+            // fresh context：循环开始时 snapshot 当前 history
+            let baseHistorySnapshot = null;
+            if (useFreshContext) {
+                baseHistorySnapshot = ctx.history.slice();
+            }
+            if (isWhileMode) {
+                // ===== WHILE 循环模式 =====
+                const asName = step.as ?? '_iter';
+                let iterCount = 0;
+                let shouldBreak = false;
+                while (iterCount < maxIter) {
+                    if (ctx.signal?.aborted) {
+                        yield { type: 'interrupted' };
+                        return true;
+                    }
+                    // 注入迭代变量
+                    vars.push();
+                    vars.set(asName, iterCount);
+                    vars.set(`${asName}_idx`, iterCount);
+                    // fresh context：每轮重置 history 到循环入口快照
+                    if (useFreshContext && baseHistorySnapshot) {
+                        ctx.history.length = 0;
+                        ctx.history.push(...baseHistorySnapshot);
+                    }
+                    yield {
+                        type: 'plugin_progress',
+                        pluginId: WF_PLUGIN_ID,
+                        current: iterCount + 1,
+                        max: maxIter,
+                        message: `while-loop ${step.id} 迭代 ${iterCount + 1}/${maxIter}`,
+                    };
+                    const childHalted = yield* runSteps(step.do ?? [], vars, ctx, state);
+                    vars.pop();
+                    if (childHalted) {
+                        // 区分 break 退出和 error/halt 退出
+                        // break 由 runSteps 内部处理，返回 true 但不 yield error
+                        // 这里统一返回 true（跳出外层循环）
+                        return true;
+                    }
+                    iterCount++;
+                }
+                await state.appendProgress(`✓ ${step.id} (while ×${iterCount}, 达到上限 ${maxIter})`);
+                await state.writeVars(vars.snapshot());
+                yield {
+                    type: 'workflow_step_end',
+                    id: step.id,
+                    ok: true,
+                    output: `while loop ${iterCount} iterations (max=${maxIter})`,
+                };
+                continue;
+            }
+            // ===== FOR-EACH 循环模式（原有逻辑） =====
             let arr;
             try {
                 arr = evalExpr(step.over ?? '[]', vars);
@@ -212,6 +309,11 @@ async function* runSteps(steps, vars, ctx, state) {
                 vars.push();
                 vars.set(asName, arr[idx]);
                 vars.set(`${asName}_idx`, idx);
+                // fresh context 也支持 for-each 模式
+                if (useFreshContext && baseHistorySnapshot) {
+                    ctx.history.length = 0;
+                    ctx.history.push(...baseHistorySnapshot);
+                }
                 const childHalted = yield* runSteps(step.do ?? [], vars, ctx, state);
                 vars.pop();
                 if (childHalted)
@@ -392,6 +494,35 @@ async function* runSteps(steps, vars, ctx, state) {
             };
             continue;
         }
+        // ---------- 控制流：break（循环退出信号） ----------
+        //
+        // 仅在 loop 的 do[] 内有效。命中时跳出最近一层循环。
+        // 通常配合 when 条件使用（如检测到 DONE 哨兵时跳出）；
+        // 无条件 break 极少用（等价于只跑一轮的循环）。
+        if (step.type === 'break') {
+            let shouldBreak = true;
+            if (step.when) {
+                try {
+                    shouldBreak = Boolean(evalExpr(step.when, vars));
+                }
+                catch (e) {
+                    // when 表达式错误 → 不跳出，当 skipped 处理
+                    shouldBreak = false;
+                }
+            }
+            if (shouldBreak) {
+                await state.appendProgress(`↵ ${step.id}: break（跳出循环）`);
+                yield { type: 'workflow_step_end', id: step.id, ok: true, output: 'break' };
+                return true; // ← 关键：返回 true 让外层 runSteps / loop 终止
+            }
+            // 条件不满足 → 当 skip 处理，继续下一步
+            yield {
+                type: 'workflow_step_skipped',
+                id: step.id,
+                reason: 'break 条件不满足',
+            };
+            continue;
+        }
         // ---------- 普通动作 step：tool / llm / skill / assert ----------
         try {
             const result = yield* dispatchActionStep(step, vars, ctx);
@@ -499,8 +630,12 @@ export async function* runWorkflow(def, inputs, ctx) {
     // onError:'recover' 用：把工作流总目标（description）透传给恢复 agent，
     // 让它知道「这条工作流到底想干什么」。已有 goal 则不覆盖。
     const runCtx = { ...ctx, goal: ctx.goal ?? def.description };
+    // 通用目标锚定：从 inputs 中提取用户的原始目标，
+    // 注入 RunContext.goalAnchor，让 agent/llm/skill 步自动前置到每步 prompt。
+    // 提取策略：优先 "goal" 命名的输入 → 其次第一个 required string 输入。
+    runCtx.goalAnchor = buildGoalAnchor(def.inputs ?? [], inputs);
     const state = new WorkflowState(getWorkingDir());
-    await state.init(def.name, inputs);
+    await state.init(def.name, inputs, def.steps);
     yield {
         type: 'workflow_start',
         name: def.name,
@@ -528,38 +663,12 @@ export async function* runWorkflow(def, inputs, ctx) {
             max: def.steps.length,
             message: `✓ workflow ${def.name} 完成`,
         };
+        // v0.9 重构：不再需要 assistant_message 摘要注入。
+        // agent/llm/skill 步已通过 runQuery(TAOR) 直接写入共享 ctx.history，
+        // 每步的完整对话上下文（user→assistant→tool→...）都自然积累在 history 中。
+        // 后续对话和用户调整都能看到完整的工作流执行过程。
         yield { type: 'workflow_done', name: def.name, vars: vars.snapshot() };
         succeeded = true;
-        // ---- 层1：写入摘要到对话历史（让后续对话记住这次 workflow 做了什么）----
-        const snapshot = vars.snapshot();
-        const summaryText = typeof snapshot.summary_text === 'string'
-            ? snapshot.summary_text
-            : '';
-        // 收集关键产出物（从 vars 中提取文件路径）
-        const artifacts = [];
-        if (typeof snapshot.plan_text === 'string')
-            artifacts.push('./PLAN.md');
-        // 检查是否有执行结果（execute_plan 步的产出）
-        if (typeof snapshot.execution_result === 'string') {
-            // 尝试从执行结果中提取文件路径（常见模式：产出物路径）
-            const fileMatches = snapshot.execution_result.match(/`[^`]*\.(pptx|docx|pdf|xlsx|md|ts|js|py)[^`]*`/g);
-            if (fileMatches)
-                artifacts.push(...fileMatches.map((f) => f.replace(/`/g, '')));
-        }
-        const summaryLines = [
-            `**工作流「${def.name}」执行完成**`,
-            ``,
-            `- 步骤: ${def.steps.length}/${def.steps.length} 全部完成`,
-            ...(artifacts.length > 0 ? [`- 产出物: ${artifacts.join(', ')}`] : []),
-            ...(summaryText ? [`- 摘要: ${summaryText}`] : []),
-        ];
-        yield {
-            type: 'assistant_message',
-            message: {
-                role: 'assistant',
-                content: summaryLines.join('\n'),
-            },
-        };
     }
     finally {
         // 成功时归档（保留 vars.json/progress.md 供后续回溯）；失败/中断时保留原状供排查

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

@@ -2,53 +2,82 @@
  * ============================================================
  *  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 上限（默认 12），允许多轮工具调用
+ *    - agent 的产出经过验证闸门（interpretMiniReActResult）
+ *    - llm 只跑单轮 chat（maxTurns=1）
  * ============================================================
  */
+import { runQuery } from '../../../../src/loop.js';
 import { interpolate } from '../expressions.js';
-import { runMiniReAct } from '../miniReAct.js';
-import { AGENT_OPENING, buildWorkflowAgentSystem, describeCaptureContract, interpretMiniReActResult, } from '../agentCommon.js';
+import { describeCaptureContract, interpretMiniReActResult, } from '../agentCommon.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) +
+    const maxTurns = step.maxTurns ?? 12;
+    // 构造用户提示：包含步骤指令 + 变量 + capture 约束 + 内部标记防护
+    const userPrompt = 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,
+        (step.input ? `\n\n上下文变量：${interpolate(step.input, vars)}` : '') +
+        '\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;
+    // 通用目标锚定：如果 runner 提供了 goalAnchor（从 inputs 自动提取），
+    // 前置注入到 prompt。确保每步 LLM 都能看到用户原始目标，
+    // 避免长上下文 / fresh_context 导致目标被稀释或遗忘。
+    const effectivePrompt = ctx.goalAnchor
+        ? `${ctx.goalAnchor}\n\n${fullPrompt}`
+        : fullPrompt;
+    // 记录 runQuery 开始前的 history 长度，用于之后提取本步的 assistant 输出
+    const historyLenBefore = ctx.history.length;
+    // 委托 TAOR 引擎执行（携带 sessionState 以启用上下文压缩）
+    yield* runQuery(effectivePrompt, {
         provider: ctx.provider,
+        history: ctx.history,
         signal: ctx.signal,
+        maxTurns,
+        chat: ctx.chat,
+        executeTool: ctx.executeTool,
+        sessionState: ctx.sessionState,
     });
-    const outcome = interpretMiniReActResult(result, !!step.output_schema);
+    // 从 history 中提取本步产生的最后一条 assistant message 内容（用于 capture 绑定）
+    let rawText = '';
+    for (let i = ctx.history.length - 1; i >= historyLenBefore; i--) {
+        const msg = ctx.history[i];
+        if (msg.role === 'assistant' && typeof msg.content === 'string' && msg.content.trim()) {
+            rawText = msg.content;
+            break;
+        }
+    }
+    // 验证闸门：判断结果是"真交付"还是"放弃"
+    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)
         throw new Error(`agent 步骤放弃: ${outcome.reason}`);
     return outcome.value;

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

@@ -3,16 +3,18 @@
  *  src/workflows/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,15 @@ export function execAssertStep(step, vars) {
             : `assertion failed: ${step.condition}`;
         throw new Error(msg);
     }
+    // ════ v0.9.3：上下文统一 —— assert 通过也留痕 ════
+    // 让后续 LLM 步骤知道某个前置条件/不变量已确认满足。
+    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,73 @@
 /**
  * ============================================================
- *  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），不期望工具调用（但 runQuery 允许模型自主决定）
+ *    - 有 context_files 时允许少量轮次读取文件后输出
+ *    - 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 { interpolate } from '../expressions.js';
+import { runQuery } from '../../../../src/loop.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 { interpolate } from '../expressions.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 子循环 =====
+    // 有 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}` : ''}`)
             .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({
+    fullPrompt += schemaHint;
+    // 通用目标锚定：同 agent.ts，确保每步 LLM 不偏离原始目标
+    const effectivePrompt = ctx.goalAnchor
+        ? `${ctx.goalAnchor}\n\n${fullPrompt}`
+        : fullPrompt;
+    // llm 步默认单轮；有 context_files 时允许多轮（读文件→输出）
+    const maxTurns = step.maxTurns ?? (step.context_files?.length ? 10 : 1);
+    // 记录 history 长度用于提取本步输出
+    const historyLenBefore = ctx.history.length;
+    // 委托 TAOR 引擎执行（携带 sessionState 以启用上下文压缩）
+    yield* runQuery(effectivePrompt, {
         provider: ctx.provider,
-        messages,
-        tools: [],
-        responseFormat,
+        history: ctx.history,
         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('用户中断');
+        maxTurns,
+        chat: ctx.chat,
+        executeTool: ctx.executeTool,
+        sessionState: ctx.sessionState,
+    });
+    // 从 history 提取本步最后一条 assistant 消息
+    let rawText = '';
+    for (let i = ctx.history.length - 1; i >= historyLenBefore; i--) {
+        const msg = ctx.history[i];
+        if (msg.role === 'assistant' && typeof msg.content === 'string' && msg.content.trim()) {
+            rawText = msg.content;
+            break;
         }
     }
-    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);
+    const trimmed = rawText.trim();
+    // 结构化输出模式：解析 JSON
+    if (step.output_schema) {
+        const payload = extractJsonPayload(trimmed);
         let parsed;
         try {
             parsed = JSON.parse(payload);
@@ -142,7 +83,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,