mocode-ai 1.1.7 → 1.1.9

package/dist/agent/core.js

@@ -5,39 +5,32 @@
 // 与 index.ts 的关系:index.ts 的 runAgent = runAgentCore + TUI hooks 薄封装(行为不变)。
 // spawn.ts 的 spawnAgent = runAgentCore + 静默 hooks(子 agent)。
 import { readFileSync } from 'node:fs';
+import { getNotesMtime } from '../session/notes.js';
 import { chat, estimatePromptTokens, planChatTools, chatTools, } from '../llm/index.js';
 import { executeToolOutcome, getToolCapabilities, isFileMutationTool, tools, } from '../tools/registry.js';
 import { checkPermission } from '../permissions/index.js';
 import { validateToolArguments } from '../tools/validation.js';
 import { getPlanDisabledTools, getRuntimeDisabledTools } from '../tools/constants.js';
-import { createPreCompletionChecklistMiddleware, } from './middleware/checklist.js';
-import { inferModelFamily } from './work-discipline.js';
-import { reflectionHint, classifyError } from './retry-classifier.js';
 import { getAgentMode, setAgentMode } from './mode.js';
-import { maybeCompact, contextState, dropContextFromHistory, createTraceEvent, summarizeToolArguments, safeProviderId, } from '../session/index.js';
+import { maybeCompact, contextState, createTraceEvent, summarizeToolArguments, safeProviderId, } from '../session/index.js';
+import { capToolResultForHistory } from '../session/compact.js';
 import { createBudgetScheduler } from '../session/scheduler.js';
-import { optimizeToolResult, HOT_TURN_WINDOW, userTurnBoundary, recordArtifact, invalidateArtifacts, rehydrateArtifacts, } from '../context/index.js';
-import { createAgeAwareEncodingState, } from '../context/age-aware.js';
+import { recordArtifact, invalidateArtifacts, rehydrateArtifacts, } from '../context/index.js';
 import { createRelevancePruner } from '../context/relevance.js';
 import { isToolResultSuccess } from '../context/utils.js';
-import { config } from '../config/index.js';
+import { config, extractActivePlanSection, reinjectActivePlanIntoSystem } from '../config/index.js';
 import { t } from '../i18n/index.js';
 import { jailResolve } from '../sandbox/index.js';
 import { createLifecycleEngine } from '../context/lifecycle.js';
 import { getTokenCalibration, updateTokenCalibration, } from '../context/token-calibration.js';
 import { getCurrentTurnId, getCurrentTurnMutationState } from '../rollback/index.js';
-import { createAutomaticValidator, } from '../verification/index.js';
 import { getCurrentSessionId } from '../session/state.js';
-/** Stable per-history age state survives user turns; WeakMap avoids retaining closed sessions. */
-const ageAwareStateByHistory = new WeakMap();
-function ageAwareStateFor(history) {
-    const existing = ageAwareStateByHistory.get(history);
-    if (existing)
-        return existing;
-    const created = createAgeAwareEncodingState(history);
-    ageAwareStateByHistory.set(history, created);
-    return created;
-}
+/** nag 提醒阈值:连续 N 个"执行了工具但没更新 notes.md"的步后提醒一次(对齐 Claude Code TodoWrite 的 3 轮)。 */
+const PLAN_NAG_THRESHOLD = 3;
+/** nag 提醒文本:注入到当前步第一条 tool_result 内容前(与最新工具输出同批被模型看到,而非单独一条易被冲淡)。 */
+const PLAN_NAG_TEXT = '[mocode] Reminder: you have an active plan in notes.md but have not updated it recently. ' +
+    'If you finished a step, call plan_update to check it off (keep at most one in_progress); ' +
+    'if the whole plan is done, let plan_update settle it to ## Done:. If the plan changed scope, update it to match reality.';
 /** 解析工具 arguments JSON;非法或空返 null(调用方据此降级到普通 preview)。 */
 function parseArgs(raw) {
     try {
@@ -47,49 +40,6 @@ function parseArgs(raw) {
         return null;
     }
 }
-/**
- * Thrashing 检测:同一工具 + 完全相同 arguments 在本轮重复 ≥ THRASH_THRESHOLD 次,
- * 返一段提示(注入到工具结果尾部),引导模型换思路而不是再试一次。
- * 阈值 2 = "试过两次同样的调用还没好,该停了"。指纹 = `${name}\\x00${args}`
- * (直接拼,不哈希——避免热路径开销;args 长度本身有限,内存压力可忽略)。
- * null 表示未触发,不污染输出。
- */
-const THRASH_THRESHOLD = 2;
-function thrashHint(name, args, count) {
-    if (count < THRASH_THRESHOLD)
-        return null;
-    return (`\n\n[hint] This is call #${count} of \`${name}\` with identical arguments — ` +
-        'either failing or returning the same content. STOP retrying and switch strategy:\n' +
-        '- read_file / glob → path likely wrong; call `glob` to discover paths, or `ask_human`\n' +
-        '- run_command → Windows path-escaping issue; use `read_file` / `glob` with absolute paths instead\n' +
-        '- write_file / edit_file CHANGE_CONFLICT → do not resend; read_file the same path and use its latest hash (use null only when read_file says the path is missing)\n' +
-        '- edit_file old_string mismatch → re-read the exact region and copy it verbatim\n' +
-        '- otherwise → re-read the tool description; the argument shape may be wrong');
-}
-/**
- * Detect only a strict streak of identical failures. Successful calls, or a
- * different tool/argument pair, end the streak. This keeps intentional phased
- * read_file/glob calls from being mislabeled after the underlying files change.
- */
-export function createThrashTracker() {
-    let lastFailedFingerprint = null;
-    let consecutiveFailures = 0;
-    return (name, args, succeeded) => {
-        if (succeeded) {
-            lastFailedFingerprint = null;
-            consecutiveFailures = 0;
-            return null;
-        }
-        const fingerprint = `${name}\x00${args}`;
-        if (fingerprint === lastFailedFingerprint)
-            consecutiveFailures += 1;
-        else {
-            lastFailedFingerprint = fingerprint;
-            consecutiveFailures = 1;
-        }
-        return thrashHint(name, args, consecutiveFailures);
-    };
-}
 /** 只有显式声明 parallel 且无需权限确认的工具才进入普通并发组。 */
 function isParallelTool(name) {
     const tool = tools.find((candidate) => candidate.name === name);
@@ -158,86 +108,18 @@ function readDiffContext(tc, parsed) {
     }
     return { preWriteOld: null, editStartLine: 1 };
 }
-/** 回灌 tool 结果到 history:经 Context Optimization Pipeline 编码(tree/search/log/...)后裁到单条上限。
- *  tool_call_id 与 assistant.tool_calls 按序配对。未注册 encoder 时回落 capToolResultForHistory(零行为变化)。
- *  TUI 渲染(hooks.onToolResult)用原始 output,与此解耦——屏上看全量,LLM 看编码后紧凑版。
- *  出口再经 Relevance Pruner 做跨条裁剪:同 path 旧 read_file 自动 stub 为存根。
- *  - pruner 在每个 runAgentCore 实例化一次(本闭包持有),会话级状态。
- *  - 开关关闭时 pruner 不创建(零开销、零行为变化)。
- *  出口再经 Lifecycle Engine 做引用追踪:LIVE→REFERENCED→OBSOLETE→STUB 四态。
- *  - lifecycle 也在每个 runAgentCore 实例化一次,登记 grep/glob/web_search/web_fetch 等 producer
- *    与 read/edit/write 的 consumer 关系;孤立+老化自动 STUB(观察类工具永不到 STUB)。
- *  - 开关关闭时 lifecycle=null 完全跳过。 */
-/** RETRY-01: 把 thrash hint + 反思指针一次性拼到 output 尾部。
- *  - thrash hint 永远可能存在(连续失败才出现);
- *  - 反思指针仅在 error/denied 状态追加,success 跳过避免噪声。
- *  抽出 helper 是为了 sequential + parallel 两处共用,避免拼装逻辑漂移。
- *  返回追加后的字符串 + 反思 category(用于 QUAL-01 trace 硬事件),
- *  success / aborted 时 category === null,调用方据此决定是否 emit 'retry_reflection' 事件。 */
-function appendRetryAnnotations(output, status, code, thrashHint) {
-    let result = thrashHint ? `${output}${thrashHint}` : output;
-    let reflectionCategory = null;
-    if (status !== 'success' && status !== 'aborted') {
-        reflectionCategory = classifyError(code);
-        const reflection = reflectionHint(reflectionCategory);
-        result = `${result}\n\n[retry reflection: ${reflectionCategory}]\n${reflection}`;
-    }
-    return { output: result, reflectionCategory };
-}
-/** ASK-01: ask_human 工具调用本 turn 计数器。纯函数无副作用,
- * 计数规则简单:1-based(本 turn 第 1 次 = 1, 第 2 次 = 2, 第 3+ 次 = exceeded)。
- * 预算上限常量与工作纪律段 "Budget: at most 2 ask_human calls per turn" 保持一致;
- * 改这里时,fixture 与纪律段都要同步。 */
-export const ASK_HUMAN_PER_TURN_BUDGET = 2;
-export function askHumanBudgetAnnotation(askHumanCountThisTurn, status) {
-    // 工具失败 / aborted 不追加(避免噪声;模型已被错误消息告知失败)。
-    if (status !== 'success')
-        return null;
-    if (askHumanCountThisTurn < ASK_HUMAN_PER_TURN_BUDGET)
-        return null;
-    if (askHumanCountThisTurn === ASK_HUMAN_PER_TURN_BUDGET) {
-        return `\n\n[ask budget] This was your ${askHumanCountThisTurn}nd ask_human call this turn (budget = ${ASK_HUMAN_PER_TURN_BUDGET}). For the rest of this turn, prefer the safer default and disclose the choice in your final reply — do not silently guess.`;
-    }
-    // 第 3+ 次(超过预算):强硬提示,鼓励模型停下问自己是否还有意义。
-    return `\n\n[ask budget EXCEEDED] This is ask_human call #${askHumanCountThisTurn} this turn (budget = ${ASK_HUMAN_PER_TURN_BUDGET}). Stop asking; choose a default, implement, and disclose the choice in your final reply. Continuing to ask is more harmful than a documented guess.`;
-}
-/** NARR-01: 工具轮旁白(assistant 消息同时带 content + tool_calls)的软预算。
- * 超出即追加回压提示;未超只 emit trace(可度量,不打扰)。
- * 单位是 code point 而非字节——中文一字一 point,英文一字母一 point,
- * 对两种语言都是"一句话大约多长"的直觉量级。 */
-export const NARRATION_CHAR_BUDGET = 120;
-/** 分类工具轮旁白。返回 null 表示这一轮没有旁白(纯工具调用,理想情况)。
- * hint 仅在超预算时非 null:prompt 里的"工具轮保持静默"是软约束,
- * 这里给出机制层面的回压,同时让 trace 能统计旁白率。 */
-export function classifyNarration(content, toolCallCount) {
-    const text = content?.trim() ?? '';
-    if (!text)
-        return null;
-    const chars = [...text].length;
-    if (chars <= NARRATION_CHAR_BUDGET) {
-        return { chars, overBudget: false, hint: null };
-    }
-    const plural = toolCallCount === 1 ? '' : 's';
-    return {
-        chars,
-        overBudget: true,
-        hint: `\n\n[narration] Your previous message emitted ${chars} characters of prose alongside ` +
-            `${toolCallCount} tool call${plural} (soft budget = ${NARRATION_CHAR_BUDGET}). ` +
-            'Interstitial commentary costs the user screen space and costs you context on every ' +
-            'later step. For the rest of this turn, emit prose mid-turn ONLY to (a) flag a genuine ' +
-            'decision fork needing user input, (b) disclose an error or risk, or (c) deliver the ' +
-            'final answer once tools are done. Otherwise call the next tool with no preamble.',
-    };
-}
+/** 回灌 tool 结果到 history。
+ *  正常路径只做单条 hard cap；原始 output 同时供 TUI 展示，因此用户与模型
+ *  看到同一事实。Artifact/Relevance/Lifecycle 仅登记 metadata/provenance，
+ *  不在这里改写旧正文；所有自动清理与压缩统一由 80% pressure scheduler 决定。 */
 function pushToolResult(history, tc, output, pruner, lifecycle, _scheduler, runtimeContextState = contextState, succeededOverride) {
     const succeeded = succeededOverride ?? isToolResultSuccess(output);
-    const ageAware = config.contextOptimize ? ageAwareStateFor(history) : null;
-    const encodingContext = ageAware?.preparePush(tc, succeeded);
     const msg = {
         role: 'tool',
         tool_call_id: tc.id,
-        // 初次 push 始终保守(age=0);旧 Cold 结果在下一 step 的 sweep 中按类型降级。
-        content: optimizeToolResult(tc.name, output, tc.arguments, encodingContext),
+        // Preserve evidence verbatim in normal operation; the hard per-result cap
+        // remains solely as a request-size safety rail.
+        content: capToolResultForHistory(tc.name, output),
     };
     history.push(msg);
     const messageIndex = history.length - 1;
@@ -253,8 +135,8 @@ function pushToolResult(history, tc, output, pruner, lifecycle, _scheduler, runt
  * agent 核心循环(纯逻辑):
  *  流式调 LLM(经 hooks.onText 实时渲染)→ 有 tool_calls 就分组执行并回灌
  *  → 否则流式正文即最终回复。history 在调用间持久,由调用方持有。
- *  步前经 session/maybeCompact 自动压缩(接近窗口上限时三层压缩);
- *  工具结果进 history 前经 Context Optimization Pipeline(optimizeToolResult:类型化编码 + 长度裁剪)。
+ *  步前由 session scheduler 检查真实 context pressure；达到 80% 时统一清理并压缩历史。
+ *  工具结果正常只经 capToolResultForHistory 的单条 hard safety cap。
  *
  *  中断语义:signal 经 executeTool(name, args, signal) 串进工具;run_command/web_fetch 等 abort 即时杀
  *  (树杀子进程 / 取消 fetch),循环顶 if(signal.aborted) 兜底还原。不会留下未配对的 tool_call_id。
@@ -267,25 +149,8 @@ function pushToolResult(history, tc, output, pruner, lifecycle, _scheduler, runt
 export async function runAgentCore(opts) {
     const { history, userInput, signal, onContextUpdate, hooks } = opts;
     const runtimeContextState = opts.contextState ?? contextState;
-    // ASK-01: 本 turn 已使用的 ask_human 次数(每次 tool call 后递增)。
-    // 预算超过时,工具结果尾部追加 ask budget 提示,不直接拒绝调用(更轻量,
-    // 也避免和现有 permission 系统的"拒绝"语义重叠)。
+    /** 本轮 ask_human 成功调用次数，仅用于 trace 观测，不影响工具执行或模型上下文。 */
     let askHumanCountThisTurn = 0;
-    // NARR-01: 上一条 assistant 消息(带 tool_calls)超出旁白预算时,待注入的回压提示。
-    // 只挂在本批次的第一条工具结果上并立即清空——重复注入会变成新的噪声源。
-    let pendingNarrationHint = null;
-    /** 取出并清空待注入的旁白回压提示(每批工具只消费一次)。 */
-    const takeNarrationHint = () => {
-        const hint = pendingNarrationHint;
-        pendingNarrationHint = null;
-        return hint;
-    };
-    // PROMPT-02: 解析 preCompletionChecklist 选项。undefined = 启用默认 middleware;
-    // false = opt-out(checklist 自身调试用);function = 调用方自定义。
-    const _checklistMiddleware = createPreCompletionChecklistMiddleware();
-    const preCompletionChecklistHandler = opts.preCompletionChecklist === false
-        ? null
-        : (opts.preCompletionChecklist ?? _checklistMiddleware.handler);
     const maxSteps = opts.maxSteps ?? config.maxSteps;
     // 中断还原:repl 的 /plan / /auto / Shift+Tab 等用户面触发 setAgentMode 中途切了模式,
     // abort 时连同模式一起还原回轮首。模型不再持有 switch_mode 工具,无法自切。
@@ -318,14 +183,17 @@ export async function runAgentCore(opts) {
     let done = false; // 正常完毕 / 达上限 true;中断 false(不显摘要)
     let traceStatus = 'error';
     let toolCallCount = 0;
-    let latestValidation;
-    const initialMutationVersion = getCurrentTurnMutationState().version;
-    let validatedMutationVersion = initialMutationVersion;
-    let fullyValidatedMutationVersion = initialMutationVersion;
-    const validator = opts.validator ?? createAutomaticValidator();
+    // A+B(plan 可靠性):跨步计数"执行了工具但没改动 notes.md"的连续步数。
+    // 本步写了 notes.md(plan_update 或直接 write/edit)→ 清零并重同步 history[0];
+    // 否则累计,达阈值则在当前步 tool_result 前注入 nag 提醒。
+    let stepsSincePlanTouch = 0;
     // 本轮 token 累计:每步 chat() 返回后把 result.usage 累加,供 onDone 摘要行 + AgentRunResult.usage
     // 透传给 repl(显示在底栏模式 chip 右边)。未开启 include_usage 或全失败时为 undefined。
     let turnUsage;
+    // 实时 chip ↻ 估算用:上一步 chat 实测 prompt(前缀缓存下当前步命中 ≈ 它)+ 后端是否报过 cache 命中
+    // (从不报 cache 的后端不估算,避免虚显 ↻)。
+    let lastStepPromptTokens = 0;
+    let providerCacheSeen = false;
     const addUsage = (u) => {
         if (!u)
             return;
@@ -340,48 +208,30 @@ export async function runAgentCore(opts) {
             : u;
     };
     const addToolUsage = (outcome) => addUsage(outcome.usage);
-    // Only consecutive identical failures are thrashing. Any success (including
-    // a mutation between two reads) or different call resets the streak.
-    const recordAndHint = createThrashTracker();
     history.push({ role: 'user', content: userInput });
     // 中断回滚快照:push 用户消息后整段浅拷贝。abort 时 length=0;push(...saved) 还原。
     // 这样中断时至少保留用户消息(及之前的历史);每步工具全部执行完毕后刷新快照,
     // 保留已完成的 assistant+tool_calls+tool 结果,只丢弃当前未完成步骤的消息。
     // 用 slice() 而非 length:maybeCompact 会原地重建(length=0;push(...rebuilt)),savedLen 会失效。
     let savedHistory = history.slice();
-    // drop_context 工具的上下文剔除回调:闭包捕获 history,原地剔除无关旧 tool 结果。
-    // 保护由 dropContextFromHistory 内部保证:history[0](system)+ 当前轮(最后 user 及其后)永不剔除。
-    // 子 agent 也在自己的 history 上操作(子 agent 独立 history)，文件回滚事务则与主轮共享。
-    const dropContext = (filter) => dropContextFromHistory(history, filter);
-    // 相关性裁剪 pruner:每个 runAgentCore 实例一个,纯静态、不调 LLM、自动判定 read_file 失效。
-    // 开关关闭时为 null,所有 pushToolResult 调用走无 pruner 路径(零行为变化)。
+    // Relevance and lifecycle collect provenance during normal work. Neither path
+    // rewrites history; exact supersession is applied only by the pressure scheduler.
     const relprune = config.contextRelprune ? createRelevancePruner() : null;
-    // 观察者生命周期引擎:每个 runAgentCore 实例一个,纯静态、自动维护 grep/glob/web_search/web_fetch 等
-    // producer 与 read/edit/write 的 consumer 引用关系;孤立+老化的非观察类工具自动 STUB。
-    // 开关关闭时为 null,所有 pushToolResult / mutation 调用走无 lifecycle 路径(零行为变化)。
-    // 引擎需要从已有会话 history 恢复观察结果的年龄和 path 索引；不能只追踪本次
-    // runAgentCore，否则跨用户轮次的 grep/glob 永远不会衰减。
     let lifecycle = config.contextLifecycle
         ? createLifecycleEngine(history)
         : null;
     runtimeContextState.lifecycleStats = lifecycle?.stats();
     rehydrateArtifacts(runtimeContextState, history);
-    // 预算调度器:每个 runAgentCore 实例一个，在 age-aware sweep 后评估并执行 warn / compact。
-    // contextBudget 开关关闭时为 null。
+    // The scheduler is the sole automatic history-rewrite entry point. It runs
+    // superseded → stale artifact → old logs/search → compact at real pressure.
+    // contextBudget=false keeps only the infrastructure compact fallback.
     const scheduler = config.contextBudget !== false
-        ? createBudgetScheduler(runtimeContextState) // 在 step 循环之外实例化一次,跨步持有 lastRunLog
+        ? createBudgetScheduler(runtimeContextState)
         : null;
-    // age-aware encoder 与 history 数组同寿命；每轮重建一次以覆盖外部 /compact 等原地修改。
-    const ageAware = config.contextOptimize ? ageAwareStateFor(history) : null;
-    ageAware?.rehydrate(history);
     // 本轮流式状态:首个正文 token 到达即停 spinner(思考期间 spinner 持续转「思考中…」,不写思考内容)。
     let mode = 'idle';
     let gotText = false;
     let lastChar = '';
-    // 早退重探:本 turn 已执行过工具但模型突然返回无工具调用 + 空文本 → 推一条提示让模型继续。
-    // 短回复也可能是合法完成结果，不再按字符数误判；每 turn 最多触发 1 次以防死循环。
-    let nudgeCount = 0;
-    let hadToolsThisTurn = false;
     const onText = (s) => {
         hooks.onText?.(s); // 主 agent:走 markdown 渲染写内容区
         mode = 'text';
@@ -408,7 +258,6 @@ export async function runAgentCore(opts) {
         hooks.onAbort?.();
         history.length = 0;
         history.push(...savedHistory);
-        ageAware?.rehydrate(history);
         setAgentMode(savedMode);
     };
     try {
@@ -427,7 +276,6 @@ export async function runAgentCore(opts) {
                         terminationReason: 'aborted',
                         finalText: null,
                         usage: turnUsage,
-                        validation: latestValidation,
                         changedFiles: mutation.changedFiles.map((item) => item.path),
                     };
                 }
@@ -439,10 +287,9 @@ export async function runAgentCore(opts) {
                 const storedCalibration = getTokenCalibration(requestBaseURL, requestModel, activeTools);
                 runtimeContextState.correction = storedCalibration.correction;
                 runtimeContextState.calibrationSamples = storedCalibration.samples;
-                // 初次 tool push 只做保守编码；预算评估前先对 Cold 且 age 达阈值的旧结果降级，
-                // 避免 scheduler 根据马上会被 sweep 的陈旧占用误触发 history compact。
-                ageAware?.sweep(history, userTurnBoundary(history, HOT_TURN_WINDOW));
-                // 步前:五区 Budget Scheduler 在优化后的 history 上决策；开关关闭时退化回原 maybeCompact 路径。
+                // The scheduler is the only automatic path that may compress old evidence.
+                // Normal tool pushes and lifecycle tracking remain metadata-only.
+                // 步前:五区 Budget Scheduler 在当前完整 history 上决策；开关关闭时退化回 maybeCompact 路径。
                 // 此时 spinner 已停,通知行干净。
                 let historyRebuilt = false;
                 const compactStartedAt = Date.now();
@@ -478,8 +325,9 @@ export async function runAgentCore(opts) {
                         lifecycle = createLifecycleEngine(history);
                         runtimeContextState.lifecycleStats = lifecycle.stats();
                     }
-                    ageAware?.rehydrate(history);
                     rehydrateArtifacts(runtimeContextState, history);
+                    // ② compact 后把活跃 plan 重注入系统提示，避免 agent 因上下文压缩丢失执行计划。
+                    reinjectActivePlanIntoSystem(history);
                 }
                 hooks.onStepStart?.(); // 主 agent:spinner.start('思考中')
                 mode = 'idle';
@@ -489,12 +337,9 @@ export async function runAgentCore(opts) {
                 const modelStartedAt = Date.now();
                 const provider = safeProviderId(requestBaseURL);
                 emitTrace('model_start', { model: requestModel, provider });
-                const dynamicSystemSuffix = [
-                    opts.dynamicSystemSuffix?.().trim() ?? '',
-                    historyRebuilt
-                        ? '## Post-compaction recovery\nContext was compacted before this request. Re-establish the current objective and unresolved work from retained evidence or the session note, avoid repeating completed investigation, and re-read exact file context before any dependent edit.'
-                        : '',
-                ].filter(Boolean).join('\n\n');
+                const dynamicSystemSuffix = historyRebuilt
+                    ? '## Post-compaction recovery\nContext was compacted before this request. Re-establish the current objective and unresolved work from retained evidence or the session note, avoid repeating completed investigation, and re-read exact file context before any dependent edit.'
+                    : '';
                 const systemMessage = history[0];
                 const requestHistory = dynamicSystemSuffix
                     && systemMessage?.role === 'system'
@@ -507,10 +352,32 @@ export async function runAgentCore(opts) {
                         ...history.slice(1),
                     ]
                     : history;
+                // 实时用量:当前步 prompt 估算(含校准系数)+ 流式累计 completion 估算,
+                // 叠上已完成步的实测 turnUsage,经 onLiveUsage 推给底栏实时 chip。
+                // turnUsage 在闭包里被 addUsage 原地更新,reportLive 每次调用读最新值。
+                const stepPromptEst = estimatePromptTokens(requestHistory, activeTools, runtimeContextState.correction);
+                const reportLive = (p) => {
+                    // 当前步 prompt:末尾 usage chunk 到达后用实测,流式期间用估算(含校准)。
+                    // 当前步 cache 命中同理:上报即用实测;流式期间按前缀缓存估算 ≈ 上一步实测 prompt
+                    // (当前 prompt 总含其为前缀),不超过当前步 prompt;后端从不报 cache 时不估算。
+                    // 口径与轮末摘要一致:chip ↑ 显计费 prompt(裸 - cached),↓/↻ 同。
+                    const curPrompt = p.promptTokens ?? stepPromptEst;
+                    const curCached = p.cachedTokens ?? (providerCacheSeen
+                        ? Math.min(lastStepPromptTokens, curPrompt)
+                        : 0);
+                    hooks.onLiveUsage?.({
+                        promptTokens: (turnUsage?.promptTokens ?? 0) + curPrompt,
+                        completionTokens: (turnUsage?.completionTokens ?? 0) + p.completionTokens,
+                        totalTokens: (turnUsage?.totalTokens ?? 0) + curPrompt + p.completionTokens,
+                        cachedTokens: (turnUsage?.cachedTokens ?? 0) + curCached,
+                    });
+                };
+                reportLive({ completionTokens: 0 }); // 思考阶段先显 ↑ prompt 估算,首 token 到达后 ↓ 开始涨
                 try {
                     result = await chat(requestHistory, {
                         onText,
                         onToolCall,
+                        onProgress: reportLive,
                         onRetry: (retry) => emitTrace('model_retry', {
                             model: requestModel,
                             provider,
@@ -547,7 +414,6 @@ export async function runAgentCore(opts) {
                             terminationReason: 'aborted',
                             finalText: null,
                             usage: turnUsage,
-                            validation: latestValidation,
                             changedFiles: mutation.changedFiles.map((item) => item.path),
                         };
                     }
@@ -566,6 +432,11 @@ export async function runAgentCore(opts) {
                 });
                 runtimeContextState.lastUsage = result.usage; // 供 /context 与状态行显示实测 token
                 addUsage(result.usage); // 本轮累计:onDone 摘要行 + AgentRunResult.usage 透传
+                if (result.usage) {
+                    lastStepPromptTokens = result.usage.promptTokens; // 下一步流式期 ↻ 估算的前缀基准
+                    if (result.usage.cachedTokens > 0)
+                        providerCacheSeen = true;
+                }
                 // 用本次实际发送的 tools 计算分母，再以 EWMA 更新 provider/model/tool-set 校准。
                 // 只持久化比例与样本数；无 usage 或短 prompt 时保持既有值。
                 if (result.usage?.promptTokens && result.usage.promptTokens > 100) {
@@ -579,7 +450,6 @@ export async function runAgentCore(opts) {
                 onContextUpdate?.();
                 if (result.toolCalls.length > 0) {
                     toolCallCount += result.toolCalls.length;
-                    hadToolsThisTurn = true;
                     // 流式正文末尾补换行(若 onToolCall 已补则 lastChar='\n',此处 no-op);防 ● 行黏在正文行尾
                     if (mode !== 'idle' && lastChar !== '\n')
                         hooks.onTextEnd?.();
@@ -593,21 +463,19 @@ export async function runAgentCore(opts) {
                             function: { name: tc.name, arguments: tc.arguments },
                         })),
                     });
-                    // NARR-01: 这条 assistant 消息同时带正文 + tool_calls,即"工具轮旁白"。
-                    // prompt 里的"工具轮保持静默"只是软约束,这里补上机制层:
-                    //   - 永远 emit trace(旁白率可度量,不再靠肉眼感觉);
-                    //   - 超预算时把回压提示挂到本批第一条工具结果尾部(复用 thrash/ask
-                    //     budget 已验证的注入接缝,不新增消息、不打断工具流)。
-                    const narration = classifyNarration(result.content, result.toolCalls.length);
+                    // A+B:记录本步第一条 tool_result 的下标 + 执行前 notes.md 的 mtime,
+                    // 工具全部执行完后据此判断"本步是否改动了 notes.md"(重同步 / nag)。
+                    const toolResultStartIdx = history.length;
+                    const notesMtimeBefore = getNotesMtime();
+                    // Record interstitial narration for observability only. It never changes tool output
+                    // or injects instructions back into the model context.
+                    const narration = result.content?.trim() ?? '';
                     if (narration) {
                         emitTrace('narration', {
-                            chars: narration.chars,
+                            chars: [...narration].length,
                             toolCalls: result.toolCalls.length,
-                            budget: NARRATION_CHAR_BUDGET,
-                            overBudget: narration.overBudget,
                             step,
                         });
-                        pendingNarrationHint = narration.hint;
                     }
                     // 工具分组执行(保 tool_calls 原顺序)：safe parallel 工具照常并发；连续
                     // resource-locked mutation 先按序完成权限预检，再按 canonical resource lock 启动。
@@ -615,6 +483,7 @@ export async function runAgentCore(opts) {
                     // 串行工具仍是本调用列表内的屏障；渲染/history 回灌始终按原 tool_calls 顺序。
                     // executeToolOutcome 永不抛错，失败通过结构化 status/code 返回。
                     const calls = result.toolCalls;
+                    const modelAttachments = [];
                     const tracedCalls = calls.map((tc, index) => ({
                         toolCallId: `${traceTurnId}:step:${step}:tool:${index}`,
                         args: summarizeToolArguments(tc.arguments),
@@ -626,28 +495,15 @@ export async function runAgentCore(opts) {
                             tool: tc.name,
                             argumentHash: traceCall.args.sha256,
                             arguments: traceCall.args,
-                            attempt: 1,
-                            retry: 0,
                         }, {
                             toolCallId: traceCall.toolCallId,
                             ...(tc.id ? { providerToolCallId: tc.id } : {}),
                         });
                     }
-                    const traceToolRetry = (tc, index, retry) => {
-                        const traceCall = tracedCalls[index];
-                        emitTrace('tool_retry', {
-                            tool: tc.name,
-                            argumentHash: traceCall.args.sha256,
-                            attempt: retry.attempt,
-                            nextAttempt: retry.nextAttempt,
-                            waitMs: retry.waitMs,
-                            code: retry.code,
-                        }, {
-                            toolCallId: traceCall.toolCallId,
-                            ...(tc.id ? { providerToolCallId: tc.id } : {}),
-                        });
-                    };
                     const traceToolEnd = (tc, index, outcome) => {
+                        if (outcome.status === 'success' && outcome.modelAttachments?.length) {
+                            modelAttachments.push(...outcome.modelAttachments);
+                        }
                         const traceCall = tracedCalls[index];
                         emitTrace('tool_call_end', {
                             tool: tc.name,
@@ -656,9 +512,6 @@ export async function runAgentCore(opts) {
                             code: outcome.code,
                             retryable: outcome.retryable,
                             durationMs: outcome.durationMs ?? 0,
-                            attempt: outcome.attempts ?? 1,
-                            retry: Math.max(0, (outcome.attempts ?? 1) - 1),
-                            retryDelayMs: outcome.retryDelayMs ?? 0,
                             changedFiles: outcome.changedFiles ?? [],
                             staleFiles: outcome.staleFiles ?? [],
                             ...(outcome.changeSet ? { changeSet: outcome.changeSet } : {}),
@@ -683,8 +536,7 @@ export async function runAgentCore(opts) {
                                 durationMs: 0,
                             };
                             hooks.onToolResult?.(currentCall, error, null, null, 1);
-                            const hint = recordAndHint(currentCall.name, currentCall.arguments, false);
-                            pushToolResult(history, currentCall, hint ? `${error}${hint}` : error, relprune, lifecycle, scheduler, runtimeContextState, false);
+                            pushToolResult(history, currentCall, error, relprune, lifecycle, scheduler, runtimeContextState, false);
                             traceToolEnd(currentCall, i, outcome);
                             i++;
                             continue;
@@ -702,10 +554,7 @@ export async function runAgentCore(opts) {
                             for (const tc of batch)
                                 hooks.onToolHeader?.(tc);
                             hooks.onToolStart?.(batch[0].name);
-                            const started = batch.map((tc, offset) => executeToolOutcome(tc.name, tc.arguments, signal, {
-                                dropContext,
-                                onRetry: (retry) => traceToolRetry(tc, i + offset, retry),
-                            }));
+                            const started = batch.map((tc) => executeToolOutcome(tc.name, tc.arguments, signal));
                             for (let k = 0; k < batch.length; k++) {
                                 const tc = batch[k];
                                 const outcome = await started[k];
@@ -714,34 +563,15 @@ export async function runAgentCore(opts) {
                                 traceToolEnd(tc, i + k, outcome);
                                 const output = outcome.output;
                                 hooks.onToolResult?.(tc, output, null, null, 1); // 并行工具无 diff
-                                // Thrashing:history 里附 hint(UI 已用干净 output 渲染,避免屏幕噪声)
-                                const hint = recordAndHint(tc.name, tc.arguments, outcome.status === 'success');
-                                const { output: annotated, reflectionCategory } = appendRetryAnnotations(output, outcome.status, outcome.code, hint);
-                                // QUAL-01 trace 硬事件:反思指针注入计数(history 文本扫描会因 LLM 在
-                                // 正文里提一句 "[retry reflection]" 而误算,改用 core 接缝处显式 emit)。
-                                if (reflectionCategory !== null) {
-                                    emitTrace('retry_reflection', {
-                                        tool: tc.name,
-                                        code: outcome.code,
-                                        category: reflectionCategory,
-                                        attempt: outcome.attempts ?? 1,
-                                    }, tc.id ? { providerToolCallId: tc.id } : {});
-                                }
-                                // ASK-01: 计数 + 预算提示
                                 if (tc.name === 'ask_human' && outcome.status === 'success') {
                                     askHumanCountThisTurn += 1;
-                                    // QUAL-01 trace 硬事件:ask_human 真实调用计数(取代 tool_call_end.name 推断)。
                                     emitTrace('ask_human_call', {
                                         tool: tc.name,
                                         status: outcome.status,
                                         perTurnCount: askHumanCountThisTurn,
                                     }, tc.id ? { providerToolCallId: tc.id } : {});
                                 }
-                                const askBudget = askHumanBudgetAnnotation(askHumanCountThisTurn, outcome.status);
-                                // NARR-01: 旁白回压提示只挂本批第一条结果(takeNarrationHint 自清空)。
-                                const narrationHint = takeNarrationHint();
-                                const finalOutput = `${annotated}${askBudget ?? ''}${narrationHint ?? ''}`;
-                                pushToolResult(history, tc, finalOutput, relprune, lifecycle, scheduler, runtimeContextState, outcome.status === 'success');
+                                pushToolResult(history, tc, output, relprune, lifecycle, scheduler, runtimeContextState, outcome.status === 'success');
                             }
                             hooks.onToolDone?.();
                             i = j;
@@ -794,14 +624,12 @@ export async function runAgentCore(opts) {
                             const firstAllowed = entries.find((entry) => !entry.denied);
                             if (firstAllowed)
                                 hooks.onToolStart?.(firstAllowed.tc.name);
-                            const started = entries.map((entry, offset) => entry.denied
+                            const started = entries.map((entry) => entry.denied
                                 ? Promise.resolve(entry.denied)
                                 : executeToolOutcome(entry.tc.name, entry.tc.arguments, signal, {
-                                    dropContext,
                                     onLockAcquired: (lockedArgs) => {
                                         entry.diff = readDiffContext(entry.tc, lockedArgs);
                                     },
-                                    onRetry: (retry) => traceToolRetry(entry.tc, i + offset, retry),
                                 }));
                             for (let k = 0; k < entries.length; k++) {
                                 const entry = entries[k];
@@ -810,8 +638,7 @@ export async function runAgentCore(opts) {
                                 opts.onToolOutcome?.(entry.tc.name, entry.parsed ?? {}, outcome);
                                 traceToolEnd(entry.tc, i + k, outcome);
                                 hooks.onToolResult?.(entry.tc, outcome.output, entry.denied ? null : entry.parsed, entry.diff.preWriteOld, entry.diff.editStartLine);
-                                const hint = recordAndHint(entry.tc.name, entry.tc.arguments, outcome.status === 'success');
-                                pushToolResult(history, entry.tc, hint ? `${outcome.output}${hint}` : outcome.output, relprune, lifecycle, scheduler, runtimeContextState, outcome.status === 'success');
+                                pushToolResult(history, entry.tc, outcome.output, relprune, lifecycle, scheduler, runtimeContextState, outcome.status === 'success');
                                 const invalidatedFiles = [...new Set([
                                         ...(outcome.changedFiles ?? []),
                                         ...(outcome.staleFiles ?? []),
@@ -846,9 +673,7 @@ export async function runAgentCore(opts) {
                                     durationMs: 0,
                                 };
                                 hooks.onToolResult?.(tc, err, null, null, 1);
-                                // Thrashing:同上
-                                const hint = recordAndHint(tc.name, tc.arguments, false);
-                                pushToolResult(history, tc, hint ? `${err}${hint}` : err, relprune, lifecycle, scheduler);
+                                pushToolResult(history, tc, err, relprune, lifecycle, scheduler);
                                 traceToolEnd(tc, i, outcome);
                                 i++;
                                 continue;
@@ -877,8 +702,7 @@ export async function runAgentCore(opts) {
                                     hooks.onToolHeader?.(tc);
                                     const outcome = deniedOutcome(tc.name);
                                     hooks.onToolResult?.(tc, outcome.output, null, null, 1);
-                                    const hint = recordAndHint(tc.name, tc.arguments, false);
-                                    pushToolResult(history, tc, hint ? `${outcome.output}${hint}` : outcome.output, relprune, lifecycle, scheduler, runtimeContextState, false);
+                                    pushToolResult(history, tc, outcome.output, relprune, lifecycle, scheduler, runtimeContextState, false);
                                     traceToolEnd(tc, i, outcome);
                                     i++;
                                     continue;
@@ -891,12 +715,10 @@ export async function runAgentCore(opts) {
                             let diff = readDiffContext(tc, mutationParsed);
                             hooks.onToolStart?.(tc.name);
                             const outcome = await executeToolOutcome(tc.name, tc.arguments, signal, {
-                                dropContext,
                                 onLockAcquired: (lockedArgs) => {
                                     if (mutationParsed)
                                         diff = readDiffContext(tc, lockedArgs);
                                 },
-                                onRetry: (retry) => traceToolRetry(tc, i, retry),
                             });
                             addToolUsage(outcome);
                             opts.onToolOutcome?.(tc.name, parsed ?? {}, outcome);
@@ -904,35 +726,15 @@ export async function runAgentCore(opts) {
                             const output = outcome.output;
                             hooks.onToolDone?.();
                             hooks.onToolResult?.(tc, output, mutationParsed, diff.preWriteOld, diff.editStartLine);
-                            // Thrashing:同上(history 附 hint,UI 干净)
-                            const hint = recordAndHint(tc.name, tc.arguments, outcome.status === 'success');
-                            // RETRY-01: 同 parallel 路径,在非成功状态追加反思指针。
-                            const { output: annotated, reflectionCategory } = appendRetryAnnotations(output, outcome.status, outcome.code, hint);
-                            // QUAL-01 trace 硬事件:反思指针注入计数(history 文本扫描会因 LLM 在
-                            // 正文里提一句 "[retry reflection]" 而误算,改用 core 接缝处显式 emit)。
-                            if (reflectionCategory !== null) {
-                                emitTrace('retry_reflection', {
-                                    tool: tc.name,
-                                    code: outcome.code,
-                                    category: reflectionCategory,
-                                    attempt: outcome.attempts ?? 1,
-                                }, tc.id ? { providerToolCallId: tc.id } : {});
-                            }
-                            // ASK-01: ask_human 计数 + 预算提示(同 parallel 路径)。
                             if (tc.name === 'ask_human' && outcome.status === 'success') {
                                 askHumanCountThisTurn += 1;
-                                // QUAL-01 trace 硬事件:ask_human 真实调用计数(取代 tool_call_end.name 推断)。
                                 emitTrace('ask_human_call', {
                                     tool: tc.name,
                                     status: outcome.status,
                                     perTurnCount: askHumanCountThisTurn,
                                 }, tc.id ? { providerToolCallId: tc.id } : {});
                             }
-                            const askBudget = askHumanBudgetAnnotation(askHumanCountThisTurn, outcome.status);
-                            // NARR-01: 旁白回压提示只挂本批第一条结果(takeNarrationHint 自清空)。
-                            const narrationHint = takeNarrationHint();
-                            const finalOutput = `${annotated}${askBudget ?? ''}${narrationHint ?? ''}`;
-                            pushToolResult(history, tc, finalOutput, relprune, lifecycle, scheduler, runtimeContextState, outcome.status === 'success');
+                            pushToolResult(history, tc, output, relprune, lifecycle, scheduler, runtimeContextState, outcome.status === 'success');
                             const invalidatedFiles = [...new Set([
                                     ...(outcome.changedFiles ?? []),
                                     ...(outcome.staleFiles ?? []),
@@ -948,6 +750,48 @@ export async function runAgentCore(opts) {
                             i++;
                         }
                     }
+                    // A(事件驱动重同步):本步若改动了 notes.md,把最新 plan 块刷回 history[0],
+                    // 让模型上下文镜像当前勾选态(不再停留在轮首的旧副本)。只在 mtime 变化时触发,零额外 churn。
+                    // B(nag 提醒):连续 N 步有工具活动但没更新 plan,在当前步第一条 tool_result 前注入提醒。
+                    const notesMtimeAfter = getNotesMtime();
+                    if (notesMtimeAfter !== notesMtimeBefore) {
+                        reinjectActivePlanIntoSystem(history);
+                        stepsSincePlanTouch = 0;
+                    }
+                    else {
+                        stepsSincePlanTouch += 1;
+                        if (stepsSincePlanTouch >= PLAN_NAG_THRESHOLD) {
+                            const activePlan = extractActivePlanSection();
+                            const firstToolMsg = history[toolResultStartIdx];
+                            if (activePlan && firstToolMsg && firstToolMsg.role === 'tool' && typeof firstToolMsg.content === 'string') {
+                                firstToolMsg.content = `${PLAN_NAG_TEXT}\n\n${firstToolMsg.content}`;
+                            }
+                            stepsSincePlanTouch = 0;
+                        }
+                    }
+                    if (modelAttachments.length > 0) {
+                        const names = modelAttachments.map((attachment) => attachment.name).join(', ');
+                        const content = [
+                            {
+                                type: 'text',
+                                text: `The view_image tool loaded the following visual input: ${names}. Analyze the attached image content directly.`,
+                            },
+                            ...modelAttachments.map((attachment) => ({
+                                type: 'image_url',
+                                image_url: {
+                                    url: attachment.dataUrl,
+                                    // 不默认补 auto: OpenAI 省略时等同 auto，但 MiniMax 仅接受 low/default/high。
+                                    // 让各 provider 采用默认枚举；仅保留工具明确请求的 low/high。
+                                    ...(attachment.detail === 'low' || attachment.detail === 'high'
+                                        ? { detail: attachment.detail }
+                                        : {}),
+                                },
+                            })),
+                        ];
+                        // OpenAI tool-call protocol requires every tool result to immediately follow the
+                        // assistant tool_calls message; append visual input only after the full batch.
+                        history.push({ role: 'user', content });
+                    }
                     // 工具步末尾补一空行:与下一轮的思考 / 正文分隔(否则 ↳ 后紧接 ▎ 思考,无空行不好看;
                     // 与正文→● 的 1 空行对称)。工具结果已以 \n 收尾,此处再补 \n 恰好 1 空行。
                     hooks.onToolBatchEnd?.();
@@ -958,169 +802,20 @@ export async function runAgentCore(opts) {
                 }
                 if (mode !== 'idle' && lastChar !== '\n')
                     hooks.onTextEnd?.(); // 流式末尾补换行
-                // 早退保护:本 turn 已执行过工具调用,但模型突然返回无工具 + 极短/空文本 → 很可能是在探索中途
-                // 提前"说完了"。此时推一条 user 提示消息让模型继续探索,而非直接退出。每 turn 最多 1 次,防死循环。
-                // 早退重探只处理真正的空回复。短回复可能是合法完成结果（例如精确状态标记）；
-                // 仅凭字符数继续调用会重复输出，并产生一次完整的额外模型请求。
-                const replyIsEmpty = (result.content?.trim().length ?? 0) === 0;
-                if (hadToolsThisTurn && nudgeCount < 1 && replyIsEmpty) {
-                    nudgeCount++;
-                    history.push({ role: 'assistant', content: result.content });
-                    history.push({
-                        role: 'user',
-                        content: 'You stopped before completing the task. Please continue investigating — call more tools if needed, or provide a complete answer based on what you have gathered so far.',
-                    });
-                    continue; // 带着提示再调一次 LLM
-                }
-                // 没有工具调用:候选正文已流式打印。若本轮有新的代码变更，先通过框架验证门；
-                // failed 作为 system observation 风格的 user 消息回灌，不能伪造无配对的 tool 消息。
+                // 没有工具调用：接受 agent 的完成判断。框架不自动运行测试、构建或完成门，
+                // 也不因缺少验证证据强制追加模型轮次；agent 仍可自行调用工具验证。
                 if (!gotText)
                     hooks.onNoReply?.();
-                const candidate = { role: 'assistant', content: result.content };
-                const mutationBeforeValidation = getCurrentTurnMutationState();
-                const shouldValidate = opts.autoValidate === true &&
-                    getAgentMode() !== 'plan' &&
-                    (mutationBeforeValidation.version > validatedMutationVersion || latestValidation?.status === 'failed');
-                if (shouldValidate) {
-                    history.push(candidate);
-                    emitTrace('validation_start', {
-                        mutationVersion: mutationBeforeValidation.version,
-                        changedFiles: mutationBeforeValidation.changedFiles.map((item) => item.path),
-                    });
-                    try {
-                        latestValidation = await validator(signal, {
-                            onCommandStart: (command) => hooks.onValidationStart?.(command),
-                            onPermissionDecision: (permission) => {
-                                const summary = summarizeToolArguments(JSON.stringify(permission.arguments));
-                                emitTrace('permission', {
-                                    source: 'automatic_validation',
-                                    tool: permission.tool,
-                                    decision: permission.decision,
-                                    argumentHash: summary.sha256,
-                                });
-                            },
-                        });
-                    }
-                    catch (error) {
-                        const mutation = getCurrentTurnMutationState();
-                        const message = `Automatic validation failed to run: ${error instanceof Error ? error.message : String(error)}`;
-                        const status = signal?.aborted ? 'aborted' : 'failed';
-                        latestValidation = {
-                            status,
-                            level: 'V0',
-                            output: message,
-                            durationMs: 0,
-                            diagnostics: [{
-                                    level: 'V0', source: 'verifier', severity: 'error', code: 'VERIFIER_ERROR', message,
-                                }],
-                            stages: [],
-                            verificationComplete: false,
-                            fingerprint: `verifier-error-${mutation.version}`,
-                            inputFingerprint: `mutation-${mutation.version}`,
-                            inputMutationVersion: mutation.version,
-                            affectedPackages: [],
-                            changedFiles: mutation.changedFiles.map((item) => item.path),
-                            mutationVersion: mutation.version,
-                        };
-                    }
-                    emitTrace('validation_end', {
-                        status: latestValidation.status,
-                        level: latestValidation.level,
-                        durationMs: latestValidation.durationMs,
-                        verificationComplete: latestValidation.verificationComplete,
-                        skipReason: latestValidation.skipReason,
-                        fingerprint: latestValidation.fingerprint,
-                        mutationVersion: latestValidation.mutationVersion,
-                        stages: latestValidation.stages.map((stage) => ({
-                            level: stage.level,
-                            status: stage.status,
-                            adapter: stage.adapter,
-                            code: stage.diagnostics[0]?.code,
-                            durationMs: stage.durationMs,
-                            cached: stage.cached === true,
-                        })),
-                    });
-                    hooks.onValidationResult?.(latestValidation);
-                    validatedMutationVersion = latestValidation.mutationVersion;
-                    if (latestValidation.status === 'passed' && latestValidation.verificationComplete) {
-                        fullyValidatedMutationVersion = latestValidation.mutationVersion;
-                    }
-                    if (signal?.aborted || latestValidation.status === 'aborted') {
-                        abortRestore();
-                        traceStatus = 'aborted';
-                        const mutation = getCurrentTurnMutationState();
-                        return {
-                            completed: false,
-                            terminationReason: 'aborted',
-                            finalText: null,
-                            usage: turnUsage,
-                            validation: latestValidation,
-                            changedFiles: mutation.changedFiles.map((item) => item.path),
-                        };
-                    }
-                    if (latestValidation.status === 'failed') {
-                        history.push({
-                            role: 'user',
-                            content: '[System observation: automatic validation failed]\n' +
-                                `Command: ${latestValidation.command ?? '(internal verifier)'}\n` +
-                                `${latestValidation.output}\n\n` +
-                                'Fix the reported problem, then finish the task. Do not claim success until validation passes.',
-                        });
-                        // 验证及其失败观察均已完整落入 history；下一步中断时可安全保留。
-                        savedHistory = history.slice();
-                        continue;
-                    }
-                }
-                else {
-                    // PROMPT-02: 硬关卡 — 收尾路径上,如果本 turn 有 mutation 且未通过
-                    // validation(autoValidate=false / 验证已 passed 但 LLM 又宣称完成),
-                    // 推一条 [checklist] user 消息,强制模型再走一轮显式确认。
-                    // 防死循环:checklist 已推过 2 次仍无新工具调用 → 放行(走原本的 push)。
-                    const finalMutationForChecklist = getCurrentTurnMutationState();
-                    const checklistCtx = {
-                        hadMutation: finalMutationForChecklist.version > 0,
-                        lastValidationStatus: (latestValidation?.status === 'failed' || latestValidation?.status === 'passed')
-                            ? latestValidation.status
-                            : 'none',
-                        mode: getAgentMode(),
-                        modelFamily: inferModelFamily(config.model),
-                    };
-                    const checklistRetryCount = history.__checklistStreak ?? 0;
-                    const shouldFireChecklist = preCompletionChecklistHandler !== null
-                        && preCompletionChecklistHandler(checklistCtx)
-                        && checklistRetryCount < 2;
-                    if (shouldFireChecklist) {
-                        history.push(candidate);
-                        history.push({
-                            role: 'user',
-                            content: _checklistMiddleware.buildUserMessage(checklistCtx.modelFamily),
-                        });
-                        history.__checklistStreak = checklistRetryCount + 1;
-                        // QUAL-01 trace 硬事件:PROMPT-02 触发计数(取代 history 文本扫描
-                        // [checklist] marker — LLM 在正文里提一句 "[checklist]" 也会被误算)。
-                        emitTrace('checklist_triggered', {
-                            streak: checklistRetryCount + 1,
-                            validationStatus: checklistCtx.lastValidationStatus,
-                            hadMutation: checklistCtx.hadMutation,
-                            modelFamily: checklistCtx.modelFamily ?? 'other',
-                        });
-                        // 重要: 不置 done,让主循环继续下一轮(模型被迫用工具或写出可验证声明)。
-                        continue;
-                    }
-                    history.push(candidate);
-                }
+                history.push({ role: 'assistant', content: result.content });
                 const finalMutation = getCurrentTurnMutationState();
                 done = true;
                 traceStatus = 'completed';
-                const verified = finalMutation.version <= fullyValidatedMutationVersion;
                 return {
                     completed: true,
-                    terminationReason: verified ? 'completed' : 'completed_unverified',
+                    terminationReason: 'completed',
                     finalText: result.content,
                     usage: turnUsage,
-                    validation: latestValidation,
                     changedFiles: finalMutation.changedFiles.map((item) => item.path),
-                    history: history.slice(),
                 };
             }
             finally {
@@ -1134,15 +829,12 @@ export async function runAgentCore(opts) {
         done = true;
         traceStatus = 'max_steps';
         const finalMutation = getCurrentTurnMutationState();
-        const hasUnverifiedChanges = finalMutation.version > fullyValidatedMutationVersion;
         return {
             completed: false,
-            terminationReason: hasUnverifiedChanges ? 'unverified_changes' : 'max_steps',
+            terminationReason: 'max_steps',
             finalText: null,
             usage: turnUsage,
-            validation: latestValidation,
             changedFiles: finalMutation.changedFiles.map((item) => item.path),
-            history: history.slice(),
         };
     }
     finally {
@@ -1154,7 +846,6 @@ export async function runAgentCore(opts) {
             toolCalls: toolCallCount,
             changedFiles: finalMutation.changedFiles.map((item) => item.path),
             totalTokens: turnUsage?.totalTokens,
-            validationStatus: latestValidation?.status,
         });
         try {
             opts.onTrace?.({
@@ -1166,7 +857,6 @@ export async function runAgentCore(opts) {
                 toolCalls: toolCallCount,
                 changedFiles: finalMutation.changedFiles.map((item) => item.path),
                 usage: turnUsage,
-                validation: latestValidation,
             });
         }
         catch {