mingdao-harness 0.1.66 → 0.1.68

package/README.md

@@ -7,7 +7,7 @@
 ## 为什么选 MingDao
 
 - ⚡ **真正的零依赖**：纯 Node.js ≥ 18，无任何 npm 运行时依赖、无构建步骤——装完即用，不拖 node_modules
-- 💰 **DeepSeek-V4 深度省钱**：384K 上下文预设、**缓存命中计价**（命中价仅为未命中的 1/30）+ 命中率仪表盘、峰谷计价（高峰＝北京工作日 9:00–12:00、14:00–18:00，闲时半价自动识别）、自动路由（pro 规划 / flash 执行 + 分类缓存 + 会话粘滞）、精确 tokenizer（官方词表 BPE）、滞回自动压缩、**Batch API 半价批处理**（`mingdao batch`）、**避峰调度**（`--offpeak` 高峰顺延到最近闲时 12:00/18:00）、**费用护栏**（每日上限防超支）
+- 💰 **DeepSeek-V4 深度省钱**：1M 上下文预设（单次输出上限 384K）、**缓存命中计价**（命中价仅为未命中的 1/30）+ 命中率仪表盘、峰谷计价（高峰＝北京工作日 9:00–12:00、14:00–18:00，闲时半价自动识别）、自动路由（pro 规划 / flash 执行 + 分类缓存 + 会话粘滞）、精确 tokenizer（官方词表 BPE）、滞回自动压缩、**Batch API 半价批处理**（`mingdao batch`）、**避峰调度**（`--offpeak` 高峰顺延到最近闲时 12:00/18:00）、**费用护栏**（每日上限防超支）
 - 🖥 **双界面 + IDE 全家桶**：产品级 TUI（流式 Markdown、代码高亮、编辑 diff、Ctrl+C 中断、Tab 补全）与 `mingdao web` 一键 WebUI（PWA 可装桌面、多任务并行、全项设置面板）；VS Code 侧边栏与 JetBrains 工具窗深度集成
 - 🧠 **36 个技能开箱即用**：14 个内置常驻 + 22 个可安装技能库（线上 registry 逐文件 sha256 校验防供应链篡改，`mingdao skill install sql` 一键装，可自建企业内 registry）
 - 🔌 **生态即插即用**：MCP 客户端（零依赖实现，`mcpServers` 配置即接入任意 MCP 服务器）+ Hooks 钩子 + 9 个 MCP 生态预设

package/docs/ARCHITECTURE.md

@@ -89,7 +89,7 @@ PreToolUse（stdin 收 JSON，stdout 输出 `{decision:"block", reason}` 可阻
 
 ## 5. 面向 DeepSeek-V4 的优化设计
 
-1. **预设调优**：v4-pro（推理/规划：温度 0.4、输出上限 32k、预算 200k）；v4-flash（日常：温度 0.6、输出 8k、预算 128k）；两者 `contextWindow` 均为 384K（正式版规格：2026-08-17 起 V4-Pro 转正商用），预算可随时调高。
+1. **预设调优**：v4-pro（推理/规划：温度 0.4、输出上限 32k、预算 200k）；v4-flash（日常：温度 0.6、输出 8k、预算 128k）；两者 `contextWindow` 均为 1M（官方规格；384K 是单次最大输出，字段 `maxOutputCeiling`），预算可随时调高。
 2. **推理内容流式展示**：`reasoning_content` 以暗色增量渲染，与正文同流。
 3. **峰谷定价适配**：每轮后展示 prompt/completion tokens，便于用户把批处理放在谷时段（v4 系列 2026-08-17 起峰谷定价，高峰＝北京工作日 9:00–12:00、14:00–18:00，闲时价＝高峰一半）。官方同时提供 Responses API 与 Anthropic 兼容接口；MingDao 默认走 OpenAI 兼容 chat/completions，如需原生协议可写自定义 Provider 模块。
 4. **模型路由（路线图）**：规划用 v4-pro、执行用 v4-flash 的自动分工；Provider 抽象已支持任意切换。

package/docs/CONFIG.md

@@ -180,6 +180,10 @@ completion 计费，防止推理吃满上限时空轮白烧）、`compactTrigger
   批处理的网关、`batchEndpoint`/`batchWindow` 覆盖协议字段。
 - **避峰执行（高峰输入价 2 倍）**：`mingdao run --offpeak` / `mingdao schedule add --offpeak`
   ——高峰时段（北京时间工作日 9:00–12:00、14:00–18:00 两段）自动顺延到最近闲时（12:00 / 18:00）执行；**周末与午间 12:00–14:00 按闲时计价**
+  · `pricing.peakWindows`：高峰窗口覆盖（[[起,止],...] 北京时间整点）；`pricing.timezone`：计价时区
+  · `pricing.source`：官方价格 JSON 地址（`mingdao update --pricing` 拉取，TTL 默认 7 天，`pricing.ttlDays` 可调）；`pricing.overrides`：按模型覆盖价格
+  · `reasoningEffort`：思考强度 low/high/max（默认模型内置 high；REPL `/think` 切换）
+  · `routing.upgradeSteps` / `routing.upgradeTruncated`：粘滞 flash 会话累计步数/截断超过阈值自动升 planner（默认 10 / 2）
   （DeepSeek 官方邮件确认），不触发避峰等待。WebUI 调度面板勾选「🌙 避峰执行」。
 
 ## 云同步

package/docs/EVALUATION-SYNTHESIS.md

@@ -44,12 +44,12 @@
 
 ## 三、下一步优化路线（按投入产出排序）
 
-### 近期（0.1.67~0.2.0，每项半天~1 天）
-1. **思考强度三档透传**（Kimi P1-B，单点收益最高）：`models.js` 加 `reasoningEffort`、Provider 透传 `reasoning_effort`，辅助调用（标题/记忆/分类器）固定 `low`，`/think low|high|max` 切换。预期简单问答输出 token 降 50%+。
-2. **上下文窗口字段修正**（Kimi P1-C）：`contextWindow` 1M、新增 `maxOutputCeiling`、pro 默认 `maxOutputTokens` 65536，减少大文件生成的续写重复计费。
-3. **价格表外置 + 自动刷新**（Hermes C1）：内置表兜底 + `~/.mingdao/pricing.json` 官方价跟随（TTL 7 天），`/cost` 在数据时点超 60 天时提示"价格表可能过期"。
-4. **轻量语义回收**（Hermes B1）：预算 80% 触发 O(1) 回收（最老 tool 消息 → 摘要行、旧 assistant 长文截前 200 字），不破坏前缀，重压缩线下移到 90%。
-5. **路由升级检测 + 第三态**（Hermes C2 / Kimi）：粘滞会话内按生成词/截断次数/工具步数允许升 planner；分类器"不确定"→ 保守走 planner。
+### 近期（0.1.67 已实施 ✅，其余顺延 0.2.0）
+1. ✅ **思考强度三档透传**（Kimi P1-B）：`models.js` 加 `reasoningEffort`、Provider 透传 `reasoning_effort`（官方 thinking_mode 参数），辅助调用（标题/记忆/分类器）固定 `low`，REPL `/think low|high|max|off` 切换。
+2. ✅ **上下文窗口字段修正**（Kimi P1-C）：`contextWindow` 1M、新增 `maxOutputCeiling:384000`、pro `maxOutputTokens` 32768→65536。
+3. ✅ **价格表外置 + 自动刷新**（Hermes C1）：内置表兜底 + `~/.mingdao/pricing.json`（`mingdao update --pricing` 从 `pricing.source` 拉取，TTL 7 天）；过期时费用标签提示刷新。
+4. ✅ **轻量语义回收**（Hermes B1）：预算 >80% 时最老 tool 消息 → 单行摘要、旧 assistant 长文截前 200 字，无需模型调用；仍超才按尾部保留丢弃。
+5. ✅ **路由升级检测 + 第三态**（Hermes C2 / Kimi）：粘滞 flash 会话累计工具步数 ≥10 或截断 ≥2 自动升 planner（`routing.upgradeSteps/upgradeTruncated` 可调）；分类器"不确定"→ 保守走 planner。
 
 ### 中期（0.2.x，2–5 天）
 6. **reasoning 回填裁剪**（MiniMax P0-2）：推理链 >1000 字符截尾 500 + 关键决策标记；>4000 完全丢弃留一句概括。
@@ -82,4 +82,4 @@
 
 - 峰谷窗口：Kimi 正确（双窗口），MiniMax 漏查 → 已按官方口径修复。
 - "无自动避峰调度"（OfficeACE 二/三）：不实，`run --offpeak` / `schedule add --offpeak` / WebUI 均已实现 → 本版修正了顺延目标。
-- 上下文窗口 384K vs 1M：Kimi 指出 384K 实为最大输出规格 → 已列入近期路线第 2 条。
+- 上下文窗口 384K vs 1M：Kimi 指出 384K 实为最大输出规格 → 0.1.67 已修正（contextWindow=1M、新增 maxOutputCeiling=384K、pro maxOutputTokens 32768→65536）。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mingdao-harness",
-  "version": "0.1.66",
+  "version": "0.1.68",
   "description": "MingDao Harness —— 开源智能体框架（Agent Harness）。零依赖、开箱即用，针对 DeepSeek-V4 系列优化，开放主流模型接入。",
   "type": "module",
   "bin": {
@@ -53,7 +53,8 @@
     "prepublishOnly": "node test/smoke.js && node test/e2e-local.js && node test/e2e-schedule.js",
     "desktop": "npm --prefix desktop start",
     "desktop:dist": "node scripts/sync-versions.mjs && npm --prefix desktop run dist:dir",
-    "desktop:sync": "node scripts/sync-versions.mjs"
+    "desktop:sync": "node scripts/sync-versions.mjs",
+    "bench": "node test/bench/bench-tokenizer.mjs && node test/bench/bench-routing.mjs && node test/bench/bench-compaction.mjs"
   },
   "devDependencies": {
     "@types/node": "^26.2.0",

package/src/agent.js

@@ -2,7 +2,7 @@
 // → PostToolUse 钩子 → 结果回填 → 循环，直到模型给出纯文本回复。
 // 附带：子代理（task 工具）、todo 清单状态、undo 备份仓、Ctrl+C 中断。
 
-import { trimMessages, clampText } from './context.js';
+import { trimMessages, clampText, messageTokens } from './context.js';
 import { compactConversation } from './compact.js';
 import { toolSchemas, dispatch } from './tools/index.js';
 import { modelPreset } from './models.js';
@@ -11,7 +11,8 @@ import { createHooks } from './hooks.js';
 import { createIO, style, C } from './ui.js';
 import { subagentModel } from './routing.js';
 import { writeAudit, redactSecrets } from './audit.js';
-import { checkCostGuard } from './cost-guard.js';
+import { checkCostGuard, costGuardConfig, todayCost } from './cost-guard.js';
+import { estimateCost } from './pricing.js';
 
 const MAX_STEPS = 24;
 const SUBAGENT_MAX_STEPS = 12;
@@ -26,6 +27,7 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
   const budget = cfg.contextBudget || preset.budgetTokens || 128000;
   const maxOutput = cfg.maxOutputTokens || preset.maxOutputTokens || 8192;
   const temperature = cfg.temperature ?? preset.temperature ?? 0.6;
+  const reasoningEffort = cfg.reasoningEffort ?? preset.reasoningEffort?.default ?? undefined;
   const hooks = createHooks(cfg.hooks, workingDir);
   const todos = [];
   // 会话级共享：调用方传入则复用（/model 切换、子代理均共享，undo 不丢失）
@@ -118,6 +120,8 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
     try {
     while (steps < stepLimit) {
       steps += 1;
+      // 同回合只读工具去重（Hermes C4）：相同 name+args 的只读调用只执行一次，结果复用回填
+      const turnToolCache = new Map();
       // 自动压缩（P3-1）：预算不足、静默裁剪即将丢弃早期段落时，先用 executor 模型
       // 把被裁段落压成摘要注入，替代「失忆」；失败/不值得时回退普通裁剪。
       if (cfg.autoCompact !== false) {
@@ -150,6 +154,39 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
       }
       const trimmed = trimMessages(messages, budget, count);
 
+      // reasoning 回填防护（MiniMax P0-2）：推理链只在 UI 流式展示、不回传消息（本就不回填）；
+      // 防御性保证——任何携带 reasoning_content 的消息发送前裁剪：>4000 字仅留概括，>1000 字截尾 500。
+      let sanitized = trimmed;
+      for (const m of sanitized) {
+        const rc = m.reasoning_content;
+        if (typeof rc === 'string' && rc.length > 4000) {
+          sanitized = sanitized.map((x) => (x === m ? { ...x, reasoning_content: `[思考过程已省略（原 ${rc.length} 字）]` } : x));
+        } else if (typeof rc === 'string' && rc.length > 1000) {
+          sanitized = sanitized.map((x) => (x === m ? { ...x, reasoning_content: rc.slice(-500) + ' …[思考过程已截断]' } : x));
+        }
+      }
+
+      // 护栏前置预估（Kimi P2-E）：发送前按本轮最坏成本估算（trimmed prompt × 未命中输入价
+      // + maxOutput × 输出价，峰谷按当前时段）；「今日已用 + 最坏成本」超上限时发送前拦截，
+      // 而不是等 200K 上下文的贵请求发出后才 block。
+      if (cfg.costGuard) {
+        const g = costGuardConfig();
+        if (g && Number(g.dailyLimitYuan) > 0) {
+          let promptTokens = 0;
+          for (const m of sanitized) promptTokens += messageTokens(m, count);
+          const worst = estimateCost(modelName, promptTokens, maxOutput, null, new Date());
+          const used = todayCost();
+          if (used + worst >= Number(g.dailyLimitYuan)) {
+            stripOrphanCalls();
+            return {
+              text: null, reasoning: '', usage, steps, finish, truncated: false, aborted: false,
+              note: `⛔ 护栏前置拦截：本轮最坏成本 ≈¥${worst.toFixed(4)}，今日已用 ≈¥${used.toFixed(4)}，合计将超过上限 ¥${Number(g.dailyLimitYuan).toFixed(2)}——请求未发出。可调高 config.costGuard.dailyLimitYuan 或改用更小模型。`,
+              durationMs: Date.now() - startedAt, perf: perf(),
+            };
+          }
+        }
+      }
+
       // 费用护栏（A2）：每轮开始前按今日实际费用检查；block 时暂停本轮并明确告知
       if (cfg.costGuard) {
         const guard = checkCostGuard();
@@ -185,10 +222,11 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
       try {
         res = await provider.chat({
           model: modelName,
-          messages: trimmed,
+          messages: sanitized,
           tools: [...toolSchemas(), ...mcpSchemas()],
           temperature,
           maxTokens: maxOutput,
+          reasoningEffort,
           signal: ac.signal,
           onDelta(d) {
             io.stopSpinner();
@@ -297,14 +335,25 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
         }
 
         // 执行单个工具（渲染「执行中」→ dispatch → 捕获异常转错误结果）
+        // 审计 Hermes C4：同回合相同参数的只读工具（read/ls/glob/grep/skill）合并执行一次，
+        // 后续相同调用直接复用结果（仍逐个回填 tool 消息以保持 tool_call_id 配对）
         async function runTool(prep) {
           io.renderToolStart?.(prep.name, prep.args);
+          const dedupKey = !prep.isMcp && READONLY_TOOLS_SET.has(prep.name) ? prep.name + ':' + JSON.stringify(prep.args || {}) : null;
+          if (dedupKey && turnToolCache.has(dedupKey)) {
+            prep.cached = true;
+            return turnToolCache.get(dedupKey);
+          }
           try {
+            let result;
             if (prep.isMcp) {
               if (!mcp) throw new Error('MCP 工具未启用');
-              return await mcp.call(prep.name, prep.args);
+              result = await mcp.call(prep.name, prep.args);
+            } else {
+              result = await dispatch(prep.name, prep.args, ctx);
             }
-            return await dispatch(prep.name, prep.args, ctx);
+            if (dedupKey) turnToolCache.set(dedupKey, result);
+            return result;
           } catch (err) {
             return JSON.stringify({ ok: false, error: String(err?.message || err) });
           }
@@ -342,7 +391,8 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
             });
           }
           const text = typeof result === 'string' ? result : JSON.stringify(result); // 紧凑 JSON（评估 B3）：嵌套结果省 10-20% 回填 token，且下轮按 prompt 重复计费
-          messages.push({ role: 'tool', tool_call_id: prep.tc.id, content: clampText(text) });
+          const prefix = prep.cached ? '（与同回合相同调用结果一致，已复用）\n' : '';
+          messages.push({ role: 'tool', tool_call_id: prep.tc.id, content: prefix + clampText(text) });
         }
 
         let i = 0;

package/src/cli.js

@@ -780,6 +780,24 @@ async function main() {
           continue;
         }
         await switchToModel(target);
+      } else if (cmd === '/think') {
+        const vals = ['low', 'high', 'max'];
+        if (!arg) {
+          io.print(`用法：/think low|high|max|off（当前：${cfg.reasoningEffort || '跟随模型默认 high'}）`);
+          continue;
+        }
+        if (arg === 'off') cfg.reasoningEffort = undefined;
+        else if (vals.includes(arg)) cfg.reasoningEffort = arg;
+        else { io.print(style('无效取值：low|high|max|off', C.red)); continue; }
+        agent = createAgent({
+          provider, permission, io, modelName, workingDir, cfg,
+          undoStore: sessionUndoStore, mcp: mcpFacade, sessionRef,
+          onCompact: (msgs) => {
+            rewriteSession(session.file, msgs);
+            persisted = msgs.length;
+          },
+        });
+        io.print(style(`✓ 思考强度：${cfg.reasoningEffort || 'off（模型默认）'}`, C.green));
       } else if (cmd === '/plan') {
         planMode = !planMode;
         io.print(style(`✓ 计划模式：${planMode ? '开' : '关'}${planMode ? '（先出计划，确认后执行）' : ''}`, C.green));

package/src/commands/update.js

@@ -5,6 +5,16 @@ import path from 'node:path';
 import { loadConfig } from '../config.js';
 
 export async function handleUpdateFamily(cmd, args) {
+  // 价格表外置刷新（Hermes C1）：mingdao update --pricing —— 从 cfg.pricing.source 拉取官方价格 JSON
+  if (cmd === 'update' && args.includes('--pricing')) {
+    const cfg = loadConfig();
+    if (!cfg) { console.log('[错误] 未初始化配置：请先运行 mingdao init'); process.exitCode = 1; return true; }
+    const { refreshPricingFromSource } = await import('../pricing.js');
+    const r = await refreshPricingFromSource(cfg);
+    console.log(r.lines.join('\n'));
+    process.exitCode = r.ok ? 0 : 1;
+    return true;
+  }
   // 自更新与回滚（git 安装形态）。
   // 评估 P3-1 子命令劫持防护：参数不合法时回退为普通提问（如 "mingdao update the docs" 是提问而非更新命令）
   if (cmd === 'update' && args.every((a) => a === '--check')) {

package/src/compact.js

@@ -99,16 +99,51 @@ export async function compactConversation({ messages, budget, count, provider, e
     .join('\n')
     .slice(0, INPUT_MAX_CHARS);
 
+  // —— 增量压缩（Kimi P2-D）：已压缩过的会话只压「旧摘要之后的新增段」，与旧摘要合并（摘要的摘要），
+  // 不再反复把早期内容送进摘要输入——第 N 次压缩输入从 O(历史) 降为 O(增量)。 ——
+  const sumIdx = messages.findIndex(
+    (m) => m.role === 'user' && typeof m.content === 'string' && m.content.includes('<conversation_summary>')
+  );
+  let incremental = false;
   let summary = null;
   let usage = null;
-  try {
-    const r = await summarizeConversation(provider, executorModel, convoText);
-    summary = r.text;
-    usage = r.usage;
-  } catch {
-    return null; // 摘要失败：退回普通裁剪
+  if (sumIdx > 0 && sumIdx + 1 < boundary) {
+    incremental = true;
+    const m = /<conversation_summary>\n([\s\S]*?)\n<\/conversation_summary>/.exec(String(messages[sumIdx].content));
+    const oldSummary = (m && m[1]) || '';
+    const newText = messages
+      .slice(sumIdx + 1, boundary)
+      .map((msg) => {
+        if (msg.role === 'tool') {
+          return `工具结果(${msg.tool_call_id ?? ''}): ${clampText(String(msg.content ?? ''), TOOL_OUTPUT_CAP)}`;
+        }
+        const head = msg.role === 'user' ? '用户' : msg.role === 'assistant' ? 'MingDao' : String(msg.role);
+        return `${head}: ${String(msg.content ?? '')}`;
+      })
+      .join('\n')
+      .slice(0, INPUT_MAX_CHARS);
+    try {
+      const r = await summarizeConversation(
+        provider,
+        executorModel,
+        `【既有摘要】\n${oldSummary.slice(0, SUMMARY_MAX_CHARS)}\n\n【新增对话记录】\n${newText}`
+      );
+      summary = r.text;
+      usage = r.usage;
+    } catch {
+      return null;
+    }
+    if (!summary) return null;
+  } else {
+    try {
+      const r = await summarizeConversation(provider, executorModel, convoText);
+      summary = r.text;
+      usage = r.usage;
+    } catch {
+      return null; // 摘要失败：退回普通裁剪
+    }
+    if (!summary) return null;
   }
-  if (!summary) return null;
 
   // 组装：system + 摘要(user) + 保留段（清洗保留段头部因裁剪而孤立的 tool 消息）
   const kept = cleanToolPairing(messages.slice(boundary));
@@ -123,5 +158,5 @@ export async function compactConversation({ messages, budget, count, provider, e
     },
     ...kept,
   ];
-  return { messages: next, droppedCount, droppedTokens, summary, usage };
+  return { messages: next, droppedCount: incremental ? boundary - (sumIdx + 1) : droppedCount, droppedTokens, summary, usage, incremental };
 }

package/src/context.js

@@ -65,18 +65,35 @@ export function trimMessages(messages, budget, count = approxTokens) {
   const hasSystem = messages[0]?.role === 'system';
   const system = hasSystem ? [messages[0]] : [];
   const rest = hasSystem ? messages.slice(1) : messages;
-  let total = system.reduce((s, m) => s + messageTokens(m, count), 0);
-  const tail = [];
-  for (let i = rest.length - 1; i >= 0; i--) {
-    const t = messageTokens(rest[i], count);
-    if (total + t > budget) break;
-    total += t;
-    tail.unshift(rest[i]);
+  const totalOf = (arr) => arr.reduce((s, m) => s + messageTokens(m, count), 0);
+  // —— 轻量语义回收（Hermes B1）：预算 >80% 时先对最老消息做无模型压缩 ——
+  // 最老 tool 消息 → 单行摘要；老 assistant 长文 → 前 200 字；逐条向新推进直到回到 80% 线。
+  // 相比直接丢弃，被修改的只有前端旧消息——其后未被触碰的近期尾部字节保持不变，
+  // 下一轮前缀缓存从首个未修改消息起继续命中（直接丢弃反而让整段前缀失配）。
+  if (totalOf(system) + totalOf(rest) > budget * 0.8) {
+    const out = [...rest];
+    for (let i = 0; i < out.length && i < 500; i++) {
+      if (totalOf(system) + totalOf(out) <= budget * 0.8) break;
+      const m = out[i];
+      const c = typeof m.content === 'string' ? m.content : JSON.stringify(m?.content ?? '');
+      if (m.role === 'tool' && c.length > 40) {
+        out[i] = { ...m, content: `[工具 ${m.tool_call_id || ''} 结果摘要：${c.slice(0, 40).replace(/\n/g, ' ')}…（已回收，原 ${c.length} 字）]` };
+      } else if (m.role === 'assistant' && c.length > 200) {
+        out[i] = { ...m, content: c.slice(0, 200) + ` …[已回收，原 ${c.length} 字]` };
+      }
+    }
+    // 回收后仍超预算 → 从尾部保留（必要时继续丢弃最老，清洗 tool 配对）
+    let total = totalOf(system);
+    const tail = [];
+    for (let i = out.length - 1; i >= 0; i--) {
+      const t = messageTokens(out[i], count);
+      if (total + t > budget) break;
+      total += t;
+      tail.unshift(out[i]);
+    }
+    return cleanToolPairing(system.concat(tail));
   }
-  const kept = cleanToolPairing(system.concat(tail));
-  // 静默裁剪：不向中间插入说明消息——保持消息前缀字节稳定，
-  // 让 DeepSeek 等支持上下文缓存的 API 最大化缓存命中（命中价仅为未命中的约 1/30）。
-  return kept;
+  return cleanToolPairing(system.concat(rest));
 }
 
 export function clampText(text, maxChars = TOOL_RESULT_LIMIT) {

package/src/memory.js

@@ -178,7 +178,7 @@ export async function extractMemory(provider, model, messages, existingMemory) {
     ];
     // 结构化输出（评估 4.2-4）：json_object，maxTokens 300→200，解析零失败；网关不支持时回退纯文本
     try {
-      const res = await provider.chat({ model, messages: msgs, tools: [], temperature: 0.2, maxTokens: 200, responseFormat: { type: 'json_object' } });
+      const res = await provider.chat({ model, messages: msgs, tools: [], temperature: 0.2, maxTokens: 200, reasoningEffort: 'low', responseFormat: { type: 'json_object' } });
       const j = JSON.parse(String(res.text || '').trim());
       const items = Array.isArray(j?.items) ? j.items : [];
       const clean = items

package/src/models.js

@@ -9,7 +9,7 @@ export const PROVIDERS = {
     baseUrl: 'https://api.deepseek.com/v1',
     envKey: 'DEEPSEEK_API_KEY',
     models: ['deepseek-v4-flash', 'deepseek-v4-pro', 'deepseek-v4-flash-vision-exp'],
-    note: 'DeepSeek-V4 正式版（2026-08-17 起商用）：384K 上下文，峰谷定价（高峰＝北京工作日 9:00–12:00、14:00–18:00，闲时价＝高峰一半），支持工具调用 / Responses API / Anthropic 兼容接口。',
+    note: 'DeepSeek-V4 正式版（2026-08-17 起商用）：1M 上下文（单次最大输出 384K），峰谷定价（高峰＝北京工作日 9:00–12:00、14:00–18:00，闲时价＝高峰一半），支持工具调用 / Responses API / Anthropic 兼容接口。',
   },
   openai: {
     label: 'OpenAI',
@@ -53,11 +53,15 @@ export const MODELS = {
   'deepseek-v4-pro': {
     label: '旗舰推理 · 复杂架构、排障、规划',
     provider: 'deepseek',
-    contextWindow: 384000, // 正式版规格：384K 上下文（2026-08-17 起商用）
+    contextWindow: 1000000, // 官方上下文 1M（审计 Kimi P1-C：384K 实为单次最大输出，字段语义修正）
+    maxOutputCeiling: 384000, // 单次最大输出上限（官方规格）
     budgetTokens: 200000, // 默认注入预算（省钱省时，可调高）
-    maxOutputTokens: 32768,
+    maxOutputTokens: 65536, // 生成类任务少续写、少重复计费（Kimi P1-C）
     temperature: 0.4,
     supportsReasoning: true,
+    // 思考强度三档（官方 thinking_mode：low/high/max）——输出按 completion 计费（输入 3 倍价），
+    // 简单任务用 low 可砍掉大部分推理 token；辅助调用（标题/记忆/分类器）固定 low
+    reasoningEffort: { default: 'high', options: ['low', 'high', 'max'] },
     // 峰谷定价（元/百万 tokens；input=缓存未命中，cacheHit=缓存命中约为未命中的 1/30）
     pricing: {
       offpeak: { input: 4.5, output: 13.5, cacheHit: 0.15 },
@@ -67,7 +71,8 @@ export const MODELS = {
   'deepseek-v4-flash': {
     label: '极速响应 · 日常问答与轻量任务',
     provider: 'deepseek',
-    contextWindow: 384000, // 正式版规格：384K 上下文
+    contextWindow: 1000000, // 官方上下文 1M
+    maxOutputCeiling: 384000,
     budgetTokens: 128000,
     maxOutputTokens: 8192,
     temperature: 0.6,
@@ -82,7 +87,8 @@ export const MODELS = {
   'deepseek-v4-flash-vision-exp': {
     label: '多模态视觉 · 图片描述/截图识别/图表分析（实验版）',
     provider: 'deepseek',
-    contextWindow: 384000,
+    contextWindow: 1000000,
+    maxOutputCeiling: 384000,
     budgetTokens: 128000,
     maxOutputTokens: 8192,
     temperature: 0.6,

package/src/pricing.js

@@ -12,6 +12,47 @@ import { mingdaoHome } from './config.js';
 // 内置价格表的数据时点（定价可能调整，配置覆盖可随时更新）
 export const PRICE_DATA_AS_OF = '2026-08';
 
+// 价格表外置（Hermes C1）：~/.mingdao/pricing.json 由「mingdao update --pricing」从
+// cfg.pricing.source 拉取（TTL 默认 7 天，cfg.pricing.ttlDays 可调）；TTL 内覆盖内置表，
+// 过期自动回退内置并置 stale 标记（/cost 与费用标签会提示）。
+function pricingFilePath() { return path.join(mingdaoHome(), 'pricing.json'); }
+let extCache = { mtime: -1, data: null, stale: false };
+function externalPricing() {
+  try {
+    const f = pricingFilePath();
+    const st = fs.statSync(f);
+    if (st.mtimeMs !== extCache.mtime) {
+      const d = JSON.parse(fs.readFileSync(f, 'utf8'));
+      const ttlDays = Number(tzCache.ttlDays ?? 7);
+      const age = Date.now() - Number(d?.fetchedAt || 0);
+      extCache = { mtime: st.mtimeMs, data: d, stale: !Number.isFinite(age) || age > ttlDays * 86400000 };
+    }
+  } catch {
+    extCache = { mtime: -1, data: null, stale: false };
+  }
+  return extCache;
+}
+export function pricingDataStale() { return externalPricing().stale; }
+
+// 拉取官方价格表（零依赖 fetch）：cfg.pricing.source 为 JSON 地址，返回 { models: { <模型名>: { input, output, cacheHit, peak? } } }
+export async function refreshPricingFromSource(cfg) {
+  const src = String(cfg?.pricing?.source || '').trim();
+  if (!src) return { ok: false, lines: ['未配置 pricing.source（config.json 的 pricing.source 填官方价格 JSON 地址后重试）'] };
+  const res = await fetch(src, { signal: AbortSignal.timeout(15000) });
+  if (!res.ok) return { ok: false, lines: ['价格源请求失败：HTTP ' + res.status] };
+  const d = await res.json();
+  const models = d && typeof d === 'object' && !Array.isArray(d) ? /** @type {any} */ (d).models : null;
+  if (!models || typeof models !== 'object' || Array.isArray(models)) {
+    return { ok: false, lines: ['价格源格式不符：应为 {"models": {"模型名": {"input":…,"output":…,"cacheHit":…,"peak":{…}}}}'] };
+  }
+  const file = pricingFilePath();
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify({ fetchedAt: Date.now(), source: src, models }, null, 2));
+  extCache = { mtime: -1, data: null, stale: false };
+  const names = Object.keys(models).join('、');
+  return { ok: true, lines: ['✓ 价格表已刷新（' + names + '），TTL 内费用估算/护栏/避峰自动跟随'] };
+}
+
 // 峰谷判断锚定北京时间（DeepSeek 官方定价页：高峰时段 = 北京时间周一至周五
 // 9:00–12:00、14:00–18:00 两段；其余（含午间 12:00–14:00 与周末全天）为闲时，闲时价 = 高峰一半）。
 // 用本机时区判断会让海外用户计费错位。config.pricing.timezone 可覆盖时区、
@@ -29,6 +70,7 @@ function peakCfg() {
         mtime: st.mtimeMs,
         timezone: String(cfg?.pricing?.timezone || 'Asia/Shanghai'),
         peakWindows: Array.isArray(pw) && pw.length ? pw : DEFAULT_PEAK_WINDOWS,
+        ttlDays: Number(cfg?.pricing?.ttlDays || 7),
       };
     }
   } catch {}
@@ -142,16 +184,19 @@ function pricingOverrides() {
 }
 function effectivePricing(modelName) {
   const preset = modelPreset(modelName);
-  if (!preset?.pricing) return null;
+  const ext = externalPricing().data?.models?.[modelName] || null;
+  if (!preset?.pricing && !ext) return null;
+  const base = ext || preset?.pricing || null;
+  if (!base) return null;
   const over = pricingOverrides()[modelName] || {}; // 审计 Q3：mtime 缓存替代每轮读盘
-  const merge = (base, o = {}) => ({
-    input: Number(o.input ?? base?.input ?? 0),
-    output: Number(o.output ?? base?.output ?? 0),
-    cacheHit: Number(o.cacheHit ?? base?.cacheHit ?? 0),
+  const merge = (b, o = {}) => ({
+    input: Number(o.input ?? b?.input ?? 0),
+    output: Number(o.output ?? b?.output ?? 0),
+    cacheHit: Number(o.cacheHit ?? b?.cacheHit ?? 0),
   });
   return {
-    offpeak: merge(preset.pricing.offpeak, over),
-    peak: merge(preset.pricing.peak || preset.pricing.offpeak, over.peak),
+    offpeak: merge(base.offpeak || base, over),
+    peak: merge(base.peak || base.offpeak || base, over.peak),
   };
 }
 
@@ -175,5 +220,5 @@ export function estimateCostLabel(modelName, promptTokens, completionTokens, usa
   const yuan = estimateCost(modelName, promptTokens, completionTokens, cache).toFixed(5);
   const hitPart =
     cache && cache.hit + cache.miss > 0 ? ` · 缓存命中 ${(cache.rate * 100).toFixed(0)}%` : ' · 未计缓存折扣';
-  return ` ≈¥${yuan}（${isPeakHour() ? '高峰' : '闲时'}${hitPart}）`;
+  return ` ≈¥${yuan}（${isPeakHour() ? '高峰' : '闲时'}${hitPart}）${pricingDataStale() ? ' · ⚠ 价格表过期，运行 mingdao update --pricing 刷新' : ''}`;
 }

package/src/providers/openai-compatible.js

@@ -6,7 +6,7 @@
  * @typedef {Error & { status?: number, headers?: Headers }} ApiError
  */
 
-export async function chat({ baseUrl, apiKey, model, messages, tools, temperature, maxTokens, signal, onDelta, includeUsage = true, responseFormat }) {
+export async function chat({ baseUrl, apiKey, model, messages, tools, temperature, maxTokens, signal, onDelta, includeUsage = true, responseFormat, reasoningEffort }) {
   const url = String(baseUrl).replace(/\/+$/, '') + '/chat/completions';
   const payload = { model, messages };
   if (temperature != null) payload.temperature = temperature;
@@ -16,6 +16,7 @@ export async function chat({ baseUrl, apiKey, model, messages, tools, temperatur
   }
   if (maxTokens) payload.max_tokens = maxTokens;
   if (responseFormat) payload.response_format = responseFormat;
+  if (reasoningEffort) payload.reasoning_effort = reasoningEffort; // 思考强度（官方 thinking_mode）
   payload.stream = true;
   // 流式响应默认不带 usage，显式请求以便展示 token/费用统计
   // （部分网关不支持该字段，可在 config.json 设 "includeUsage": false 关闭）

package/src/routing.js

@@ -19,7 +19,7 @@ export function routingConfig(cfg) {
 }
 
 const PLAN_HINTS =
-  /设计|架构|重构|审查|规划|分析|方案|评估|优化|排查|疑难|设计模式|选型|技术债|roadmap|review|design|refactor|plan|architecture|方案设计|评审/;
+  /设计|架构|重构|审查|规划|分析|方案|评估|优化|排查|疑难|报错|怎么修|修复|设计模式|选型|技术债|roadmap|review|design|refactor|plan|architecture|方案设计|评审/;
 
 // 生成类任务（游戏/网页/文档等）需要大输出（planner 32K vs executor 8K），即使短句也路由 planner
 const GENERATION_HINTS =
@@ -28,7 +28,11 @@ const GENERATION_HINTS =
 export function heuristicRoute(text, rc) {
   const s = String(text ?? '');
   if (GENERATION_HINTS.test(s)) return rc.planner; // 生成类：大输出优先
-  if (s.length >= 40 && PLAN_HINTS.test(s)) return rc.planner;
+  if (PLAN_HINTS.test(s)) {
+    // 规划类关键词优先（审计：此前要求 length>=40，导致「设计一个缓存方案」这类
+    // 13 字短句被误路由到 flash 硬扛——关键词强度优先于文本长度）
+    return s.length >= 40 || /设计|规划|分析|评估|审查|架构|重构|方案|优化|报错|修复/.test(s) ? rc.planner : null;
+  }
   if (s.length <= 60) return rc.executor;
   return null; // 需要分类器
 }
@@ -37,7 +41,7 @@ export function heuristicRoute(text, rc) {
 const ROUTE_CACHE_MAX = 100;
 const routeCache = new Map();
 
-export async function routeTask({ cfg, provider, currentModel, text, sticky = null }) {
+export async function routeTask({ cfg, provider, currentModel, text, sticky = null, sessionStats = null }) {
   const rc = routingConfig(cfg);
   if (!rc) return { model: currentModel, reason: null };
   // 当前模型已在路由池外（用户手动指定）：不干预
@@ -52,8 +56,19 @@ export async function routeTask({ cfg, provider, currentModel, text, sticky = nu
       : { model: quick, reason: quick === rc.planner ? '规划类任务' : '执行类任务' };
   }
 
-  // 会话粘滞：执行类会话不再逐轮分类（生成类关键词已在启发式拦截）
+  // 会话粘滞 + 升级检测（Hermes C2）：执行类会话不再逐轮分类（生成类关键词已在启发式拦截），
+  // 但会话内复杂度信号累积（工具步数/截断次数）时允许升级 planner——「开头简单、中途复杂」不再被 flash 硬扛。
   if (sticky === rc.executor) {
+    const stats = sessionStats || {};
+    const steps = Number(stats.steps) || 0;
+    const truncated = Number(stats.truncated) || 0;
+    const UPGRADE_STEPS = Number(cfg?.routing?.upgradeSteps) || 10;
+    const UPGRADE_TRUNCATED = Number(cfg?.routing?.upgradeTruncated) || 2;
+    if (steps >= UPGRADE_STEPS || truncated >= UPGRADE_TRUNCATED) {
+      return rc.planner === currentModel
+        ? { model: currentModel, reason: null }
+        : { model: rc.planner, reason: `会话升级：执行类已累计 ${steps} 步工具 / ${truncated} 次截断 → planner` };
+    }
     return rc.executor === currentModel
       ? { model: currentModel, reason: null }
       : { model: rc.executor, reason: '会话粘滞：执行类' };
@@ -90,6 +105,7 @@ export async function routeTask({ cfg, provider, currentModel, text, sticky = nu
       tools: [],
       temperature: 0,
       maxTokens: 20, // 结构化输出（评估 4.2-4）：80→20
+      reasoningEffort: 'low',
       responseFormat: { type: 'json_object' },
     });
     let verdict = null;
@@ -103,6 +119,11 @@ export async function routeTask({ cfg, provider, currentModel, text, sticky = nu
       if (t.includes('plan')) verdict = 'plan';
       else if (t.includes('exec')) verdict = 'execute';
     }
+    if (!verdict) {
+      // 第三态（Kimi C2）：分类器给不出结论 → 保守走 planner，避免复杂任务被 flash 硬扛
+      const m = rc.planner;
+      return m === currentModel ? { model: currentModel, reason: null } : { model: m, reason: '分类器不确定：保守走 planner' };
+    }
     if (verdict) {
       if (routeCache.size >= ROUTE_CACHE_MAX) {
         const first = routeCache.keys().next().value;

package/src/titles.js

@@ -37,6 +37,7 @@ export async function generateTitle(provider, model, firstUserText, { timeoutMs
         tools: [],
         temperature: 0.3,
         maxTokens: 50,
+        reasoningEffort: 'low',
         responseFormat: { type: 'json_object' },
         signal: ctrl.signal,
       });
@@ -51,6 +52,7 @@ export async function generateTitle(provider, model, firstUserText, { timeoutMs
         tools: [],
         temperature: 0.3,
         maxTokens: 120,
+        reasoningEffort: 'low',
         signal: ctrl.signal,
       });
       const t = cleanTitle(res.text);

package/src/tools/fs-tools.js

@@ -70,6 +70,13 @@ export function undo(args, ctx) {
   }
 }
 
+const READ_CACHE_MAX = 200; // 会话级 read 缓存条数上限（超出清最旧，防止无界增长）
+const readCache = new Map(); // 绝对路径 → { mtimeMs, size, lines }
+
+export function invalidateReadCache(p) {
+  readCache.delete(p);
+}
+
 export function read(args, ctx) {
   try {
     const p = resolvePath(ctx.cwd, args.path ?? '');
@@ -82,9 +89,24 @@ export function read(args, ctx) {
         error: `"${p}" 大小 ${(st.size / 1024 / 1024).toFixed(1)}MB，超过 ${MAX_FILE_BYTES / 1024 / 1024}MB 上限。请用 grep 搜索或 bash 分块查看。`,
       };
     }
+    // 重复读取去重（审计 MiniMax P2-2）：同一文件 mtime+size 未变且非强制重读时，
+    // 返回「内容未变化」标记（省下整段重复内容回填的 prompt token）；force=true 强制重读。
+    // 注意：带 offset/limit 的切片读取不能走缓存标记（必须返回所请求的切片）。
+    const wantsSlice = args.offset !== undefined || args.limit !== undefined;
+    const cached = readCache.get(p);
+    if (!args.force && !wantsSlice && cached && cached.mtimeMs === st.mtimeMs && cached.size === st.size) {
+      return { ok: true, output: `[内容与上次读取一致（未变化，共 ${cached.lines} 行）——如需强制重读请传 force:true]`, totalLines: cached.lines, cached: true };
+    }
     const buf = fs.readFileSync(p);
     if (isProbablyBinary(buf)) return { ok: false, error: `"${p}" 疑似二进制文件，无法按文本读取。` };
     const lines = buf.toString('utf8').split('\n');
+    if (!wantsSlice) {
+      if (readCache.size >= READ_CACHE_MAX) {
+        const first = readCache.keys().next().value;
+        if (first !== undefined) readCache.delete(first);
+      }
+      readCache.set(p, { mtimeMs: st.mtimeMs, size: st.size, lines: lines.length });
+    }
     const offset = Math.max(1, Number(args.offset) || 1);
     const limit = Math.max(1, Number(args.limit) || 400);
     // 审计质量项：offset 超出文件行数时明确提示，而非返回空内容让模型误以为文件为空
@@ -125,6 +147,7 @@ export function write(args, ctx) {
     }
     fs.mkdirSync(path.dirname(p), { recursive: true });
     fs.writeFileSync(p, content);
+    invalidateReadCache(p);
     return { ok: true, output: `已写入 ${p}（${Buffer.byteLength(content)} 字节）。` };
   } catch (err) {
     return { ok: false, error: `写入失败：${err?.message || err}` };
@@ -163,6 +186,7 @@ export function edit(args, ctx) {
     const next = replaceAll ? text.split(oldString).join(newString) : text.replace(oldString, newString);
     backup(ctx, p);
     fs.writeFileSync(p, next);
+    invalidateReadCache(p);
     const idx = text.indexOf(oldString);
     const lineStart = text.slice(0, idx).split('\n').length - 1;
     const before = regionAround(text, lineStart, oldString.split('\n').length);

package/src/web/index.html

@@ -40,6 +40,30 @@ header select{flex:none}
 @media (max-width:860px){main{padding:14px 0 8px}#chat{padding:0 10px}#envBadge{display:none!important}#sessionSearch{max-width:110px}#modelSel{max-width:110px}#permSel{max-width:120px}#sessions{max-width:110px}#wsSel{max-width:96px}header{gap:6px;padding:8px 8px}header .logo span{display:none}}
 #sessionSearch:focus{outline:none;border-color:var(--accent2)}
 #tasksPanel{position:fixed;right:0;top:52px;bottom:0;width:280px;background:var(--bg2);border-left:1px solid var(--border);z-index:40;display:flex;flex-direction:column}
+/* 输入框上方工作状态条（审计：长任务静默硬伤——实时显示执行步数/耗时与后台任务数）。
+   与输入框同宽对齐（复用 #composer 的居中容器），不再横贯整个聊天窗口 */
+#workStatus{max-width:860px;margin:0 auto 4px;display:flex;align-items:center;gap:10px;padding:6px 14px;background:var(--panel);border:1px solid var(--border);border-radius:12px;font-size:12.5px;color:var(--dim);flex:none}
+#workStatus .ws-busy{color:var(--accent2);display:flex;align-items:center;gap:8px;flex:1;min-width:0}
+#workStatus .ws-bg{cursor:pointer;color:var(--warn);white-space:nowrap}
+#workStatus .ws-bg:hover{color:var(--text)}
+/* 消息顶部轨迹行（DeepSeek-Harness 式：每轮可回溯步骤与子代理） */
+.msg-meta{display:flex;gap:8px;align-items:center;font-size:11.5px;color:var(--faint);padding:0 2px 4px}
+.trajBtn{cursor:pointer;background:var(--bg3);border:1px solid var(--border);color:var(--dim);border-radius:20px;padding:2px 10px;font-size:11.5px}
+.trajBtn:hover{color:var(--text);border-color:var(--accent2)}
+/* 轨迹面板（与任务面板互斥展示）：置于聊天窗口左侧（DSH 式侧栏） */
+#trajPanel{position:fixed;left:0;top:52px;bottom:0;width:330px;background:var(--bg2);border-right:1px solid var(--border);z-index:40;display:flex;flex-direction:column;box-shadow:4px 0 24px rgba(0,0,0,.35)}
+.tj-head{padding:12px 14px;font-size:14px;font-weight:600;border-bottom:1px solid var(--border);color:var(--accent2);display:flex;align-items:center;gap:8px}
+.tj-head button{margin-left:auto}
+#tjList{flex:1;overflow-y:auto;padding:8px}
+.tj-turn{color:var(--accent2);font-size:12px;font-weight:600;margin:8px 2px 4px}
+.tj-item{padding:6px 10px;border:1px solid var(--border);border-radius:8px;margin-bottom:6px;font-size:12.5px;background:var(--bg3);cursor:pointer}
+.tj-item:hover{border-color:var(--accent2)}
+.tj-item .tj-head{all:unset;display:flex;gap:6px;align-items:center;font-size:12.5px;color:var(--text);cursor:pointer;padding:0;border:none;margin:0}
+.tj-item .tj-args{color:var(--faint);font-size:11.5px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;min-width:0}
+.tj-item .tj-body{display:none;color:var(--dim);font-size:11.5px;margin-top:6px;white-space:pre-wrap;word-break:break-word;max-height:220px;overflow-y:auto;border-top:1px dashed var(--border);padding-top:6px}
+.tj-item.open .tj-body{display:block}
+.tj-item.tj-sub{border-color:var(--accent2)}
+.tj-item.tj-sub .tj-head{color:var(--accent2)}
 .tp-head{padding:12px 14px;font-size:14px;font-weight:600;border-bottom:1px solid var(--border);color:var(--accent2)}
 .tp-head span{color:var(--faint);font-weight:400;font-size:12px}
 #tpList{flex:1;overflow-y:auto;padding:8px}
@@ -82,6 +106,7 @@ main{flex:1;overflow-y:auto;padding:18px 0 12px;min-width:0}
 .msg-ai .content .codeblock{border:1px solid var(--border);border-radius:12px;overflow:hidden;margin:.5em 0 12px}
 .msg-ai .content .cb-banner{display:flex;justify-content:space-between;align-items:center;gap:12px;background:var(--user);border-bottom:1px solid var(--border);padding:8px 14px;font-size:12px;color:var(--dim);font-family:ui-monospace,SFMono-Regular,Consolas,monospace}
 .msg-ai .content .cb-lang{display:flex;align-items:center;gap:8px}
+.msg-sys{max-width:min(640px,92%);margin:6px auto;background:rgba(245,158,11,.08);border:1px solid rgba(245,158,11,.35);color:var(--warn);border-radius:12px;padding:8px 14px;font-size:12.5px;line-height:1.7}
 .msg-ai .content .cb-dot{width:8px;height:8px;border-radius:50%;background:var(--accent)}
 .msg-ai .content pre code{background:none;border:none;padding:0;color:#c8d3e0}
 .msg-ai .content a{color:var(--accent2)}
@@ -177,12 +202,17 @@ footer{flex:none;border-top:1px solid var(--border);background:var(--bg2);paddin
   <button id="tasksBtn" title="任务面板">任务</button><button id="sessMgrBtn" title="管理会话（重命名/删除）">✎</button>
   <button id="newChat">新对话</button>
 </header>
+<aside id="trajPanel" style="display:none">
+  <div class="tj-head">🧭 任务轨迹<span id="tjSummary" style="font-size:11.5px;color:var(--faint);font-weight:400"></span><button id="tjClose">关闭</button></div>
+  <div id="tjList"></div>
+</aside>
 <aside id="tasksPanel" style="display:none">
   <div class="tp-head">任务面板 <span id="tpCount"></span><button id="tpClose" style="float:right">✕</button></div>
   <div id="tpList"></div>
 </aside>
 <main><div id="chat"></div></main>
 <footer>
+  <div id="workStatus" style="display:none"></div>
   <input type="file" id="fileInput" accept="image/png,image/jpeg,image/gif,image/webp,.txt,.md,.json,.js,.py,.log,.csv,.html,.css" multiple style="display:none">
   <div id="attachList" style="display:none"></div>
   <div id="composer">
@@ -455,6 +485,7 @@ $('#dirPickOk').onclick = () => { const cb = pickerCb; pickerCb = null; $('#dirM
 $('#dirPickNone').onclick = () => { const cb = pickerCb; pickerCb = null; $('#dirModal').style.display = 'none'; if (cb) cb(null); };
 $('#dirPickCancel').onclick = () => { pickerCb = null; $('#dirModal').style.display = 'none'; };
 const chatEl = $('#chat'), input = $('#input'), sendBtn = $('#sendBtn');
+let activeAiMsg=null, bgRunning=0, curSteps=0, curWorkT0=0; // 本轮进度/后台任务数（工作状态条与轨迹共用）
 // 回到底部悬浮按钮：滚动容器为 main；上滚超过 300px 时出现，点击平滑回底
 (function(){
   const scroller = document.querySelector('main');
@@ -549,23 +580,22 @@ function expandableBody(previewHtml, fullHtml){
 }
 const runningTools = new Map();
 function renderToolStartEvent(ev){
-  const msg = newAiMsg();
   const card=document.createElement('div'); card.className='tool';
   const ico = {'read':'📄','write':'✏️','edit':'✎','bash':'⚙','grep':'🔎','glob':'🔎','ls':'📁','task':'👥','skill':'🧩','todo':'☑','undo':'↩'}[ev.name]||'🔌';
   const args = ev.name==='bash'? (ev.args&&ev.args.command):(ev.args&&(ev.args.path||ev.args.pattern||ev.args.name||''))||'';
   card.innerHTML='<div class="head"><span class="ico">'+ico+'</span><span class="name">'+esc(ev.name)+'</span><span class="args">'+esc(args)+'</span><span class="st" style="animation:blink 1.2s infinite">执行中…</span></div>';
-  msg.appendChild(card);
+  insertBeforeActiveMsg(card);
   runningTools.set(ev.seq, card);
   scrollBottom();
 }
 function renderToolEvent(ev){
-  const msg = newAiMsg();
   const card=document.createElement('div'); card.className='tool';
   const ico = {'read':'📄','write':'✏️','edit':'✎','bash':'⚙','grep':'🔎','glob':'🔎','ls':'📁','task':'👥','skill':'🧩','todo':'☑','undo':'↩'}[ev.name]||'🔌';
   const args = ev.name==='bash'? (ev.args&&ev.args.command):(ev.args&&(ev.args.path||ev.args.pattern||ev.args.name||''))||'';
   const r = ev.result||{};
   const ok = ev.result===undefined || r.ok!==false;
   card.innerHTML='<div class="head"><span class="ico">'+ico+'</span><span class="name">'+esc(ev.name)+'</span><span class="args">'+esc(args)+'</span><span class="st '+(ok?'ok':'bad')+'">'+(ev.result===undefined?'…':(ok?'✓':'✖'))+(ev.durationMs!=null?' '+ev.durationMs+'ms':'')+'</span></div>';
+  insertBeforeActiveMsg(card);
   const bodyWrap=(el)=>{ if(el) card.appendChild(el); };
   if(ev.name==='skill'){
     // 技能内容只供模型使用，不整篇倒给用户：一行摘要
@@ -625,7 +655,9 @@ function renderTodos(todos,msg){
   for(const t of todos){ const li=document.createElement('li'); li.className=t.status==='completed'?'done':t.status==='in_progress'?'doing':''; li.innerHTML=(t.status==='completed'?'✓ ':'○ ')+esc(t.content); ul.appendChild(li); }
   msg.appendChild(ul);
 }
-function renderBanner(ev){ const d=document.createElement('div'); d.className='banner'; d.textContent=ev.text||ev.title||''; chatEl.appendChild(d); scrollBottom(); }
+function renderBanner(ev){ const d=document.createElement('div'); d.className='banner'; d.textContent=ev.text||ev.title||''; insertBeforeActiveMsg(d); scrollBottom(); }
+// 工具卡/横幅/代码块统一插到「本轮 AI 消息」之前：结论与交付物永远位于消息最底部
+function insertBeforeActiveMsg(el){ if(activeAiMsg && activeAiMsg.parentNode){ chatEl.insertBefore(el, activeAiMsg); } else { chatEl.appendChild(el); } }
 
 function askModal(ev){
   return new Promise(resolve=>{
@@ -685,7 +717,15 @@ function renderAttachments(){
 async function send(){
   const text=input.value.trim();
   console.log('[MingDao] send 点击：generating=' + generating + ' text=' + text.length + ' attachments=' + attachments.length);
-  if(generating){ console.log('[MingDao] send 被生成态拦截 → 走 abort'); abort(); return; } // 生成中：同一按钮承担停止职责
+  if(generating){
+    // 审计（长任务静默硬伤）：任务执行中追问「是否完成」→ 界面立即如实应答当前进度，
+    // 不再静默吞掉输入；停止职责由「■ 停止」按钮承担（输入框内容保留不丢）。
+    const secs=curWorkT0?Math.round((Date.now()-curWorkT0)/1000):0;
+    const d=document.createElement('div'); d.className='msg-sys';
+    d.innerHTML='⏳ 上一个任务仍在执行（第 '+curSteps+' 步 · 已 '+Math.floor(secs/60)+' 分 '+Math.round(secs%60)+' 秒），<b>尚未完成</b>。完成后总结与交付物会自动出现在本轮消息底部；如需立即中断请点「■ 停止」。';
+    chatEl.appendChild(d); scroll();
+    return;
+  }
   if(!text && !attachments.length) return;
   const turnCtrl=new AbortController();
   // 回合看门狗（无活动超时，非总时长——审计：此前 120s 定时炸弹误杀长时间健康生成，
@@ -709,6 +749,7 @@ async function send(){
   attachments=[]; renderAttachments();
   addUser(text||(sentAttachments.map(a=>(a.type==='image'?'🖼 ':'📄 ')+a.name).join(' ')));
   const msg=newAiMsg(); const content=aiContent(msg); let raw='';
+  activeAiMsg=msg; msg._traj=[]; msg._steps=0; curSteps=0; curWorkT0=Date.now(); renderWorkStatus();
   let reason=null; let taskId=null;
   // 等待输出时的可见状态：脉动「正在思考…」（每轮生成重新显示）
   const think=document.createElement('div'); think.className='think'; think.textContent='💭 正在思考…'; msg.appendChild(think);
@@ -719,7 +760,7 @@ async function send(){
   let stepsCount=0; const workT0=Date.now();
   const hintEl=$('#hint'); const hintTextEl=$('#hintText'); const defaultHint=hintTextEl?hintTextEl.textContent:'';
   hintEl.classList.add('working');
-  const hintTimer=setInterval(()=>{ if(hintTextEl) hintTextEl.textContent='⏳ 正在工作 '+Math.round((Date.now()-workT0)/1000)+'s · 已执行 '+stepsCount+' 步 — 可点「■ 停止」中断'; },1000);
+  const hintTimer=setInterval(()=>{ if(hintTextEl) hintTextEl.textContent='⏳ 正在工作 '+Math.round((Date.now()-workT0)/1000)+'s · 已执行 '+stepsCount+' 步 — 可点「■ 停止」中断'; renderWorkStatus(); },1000);
   generating=true; setBtn(); // 本地在途状态（前置 DOM 段完成后才置位，异常不影响按钮）
   const scroller=document.querySelector('main');
   const nearBottom=()=> scroller? (scroller.scrollHeight - scroller.scrollTop - scroller.clientHeight < 90) : true;
@@ -734,26 +775,95 @@ async function send(){
     await handleEvents(resp.body, ev=>{
       if(ev.taskId) taskId=ev.taskId;
       if(ev.type==='ask') disarm(); else arm(); // 有活动→重置；权限等待→暂停计时
-      if(ev.type==='progress'){ const p=ev.seconds||0; if(think.parentNode) think.textContent='💭 正在工作 '+Math.floor(p/60)+' 分 '+Math.round(p%60)+' 秒 · 执行 '+ev.steps+' 步…'; }
+      if(ev.type==='progress'){ const p=ev.seconds||0; showThink(); think.textContent='💭 正在工作 '+Math.floor(p/60)+' 分 '+Math.round(p%60)+' 秒 · 第 '+msg._steps+' 回合 · 已执行 '+ev.steps+' 步…'; renderWorkStatus(); }
       if(ev.type==='text'){ onActivity(); raw+=ev.delta; update(); }
       else if(ev.type==='reasoning'){ if(!reason){ reason=addReasoning(msg); reason.dataset.full=''; } if(!reason.parentElement.open) reason.parentElement.open=true; reason.parentElement.querySelector('summary').classList.add('live'); reason.dataset.full+=ev.delta; const full=reason.dataset.full; reason.textContent=(full.length>9000?full.slice(-9000)+'\n…（思考内容较长，仅显示末尾；已 '+full.length+' 字符）':full); reason.scrollTop=reason.scrollHeight; scroll(); }
-      else if(ev.type==='turnStart'){ stepsCount+=1; showThink(); scroll(); }
-      else if(ev.type==='toolStart'){ stepsCount+=1; onActivity(); update(); renderToolStartEvent(ev); }
-      else if(ev.type==='code'){ onActivity(); const pre=document.createElement('pre'); pre.innerHTML='<code>'+highlight(ev.code,ev.lang)+'</code>'; content.appendChild(pre); scroll(); }
-      else if(ev.type==='tool'){ onActivity(); update(); const pending=runningTools.get(ev.seq); if(pending){ pending.remove(); runningTools.delete(ev.seq); } renderToolEvent(ev); }
-      else if(ev.type==='toolDenied'){ onActivity(); const d=document.createElement('div'); d.className='errline'; d.textContent='✖ '+(ev.reason==='未授权'||!ev.reason?'未授权':ev.reason)+'：'+ev.name; msg.appendChild(d); scroll(); }
+      else if(ev.type==='turnStart'){ stepsCount+=1; curSteps+=1; msg._steps=curSteps; msg._traj.push({kind:'turn', t:Date.now()}); showThink(); think.textContent='💭 第 '+msg._steps+' 回合：模型推理中…'; renderWorkStatus(); scroll(); }
+      else if(ev.type==='turnEnd'){ showThink(); think.textContent='⏸ 第 '+msg._steps+' 回合完成（累计 '+(ev.toolSteps||0)+' 工具步）· 进入下一回合…'; renderWorkStatus(); }
+      else if(ev.type==='toolStart'){ stepsCount+=1; curSteps+=1; msg._steps=curSteps; msg._traj.push({kind:'tool', seq:ev.seq, name:ev.name, args:ev.args, t:Date.now(), done:false}); onActivity(); update(); renderToolStartEvent(ev); renderWorkStatus(); }
+      else if(ev.type==='code'){ onActivity(); const pre=document.createElement('pre'); pre.innerHTML='<code>'+highlight(ev.code,ev.lang)+'</code>'; insertBeforeActiveMsg(pre); scroll(); }
+      else if(ev.type==='tool'){ onActivity(); update(); const pending=runningTools.get(ev.seq); if(pending){ pending.remove(); runningTools.delete(ev.seq); } const tj=msg._traj.find(x=>x.kind==='tool'&&x.seq===ev.seq); if(tj){ tj.done=true; tj.result=ev.result; tj.durationMs=ev.durationMs; tj.card=pending||null; } renderToolEvent(ev); }
+      else if(ev.type==='toolDenied'){ onActivity(); const tj=msg._traj.find(x=>x.kind==='tool'&&x.seq===ev.seq); if(tj){ tj.done=true; tj.denied=ev.reason||'未授权'; } const d=document.createElement('div'); d.className='errline'; d.textContent='✖ '+(ev.reason==='未授权'||!ev.reason?'未授权':ev.reason)+'：'+ev.name; msg.appendChild(d); scroll(); }
       else if(ev.type==='banner'){ renderBanner(ev); }
       else if(ev.type==='ask'){ update(); askModal(ev).then(a=>fetch('/api/permission',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({id:ev.id,answer:a,taskId})}).then(()=>arm()).catch(()=>{})); }
-      else if(ev.type==='usage'){ onActivity(); const u=document.createElement('div'); u.className='usage'; u.textContent=''+ev.modelName+' · ↑'+ev.usage.prompt_tokens+' ↓'+ev.usage.completion_tokens+' tokens · '+((ev.durationMs||0)/1000).toFixed(1)+'s'+ev.cost; msg.appendChild(u); scroll(); }
+      else if(ev.type==='usage'){ onActivity(); const u=document.createElement('div'); u.className='usage'; u.textContent=''+ev.modelName+' · ↑'+ev.usage.prompt_tokens+' ↓'+ev.usage.completion_tokens+' tokens · '+((ev.durationMs||0)/1000).toFixed(1)+'s'+ev.cost; msg.insertBefore(u, content); scroll(); }
       else if(ev.type==='error'){ console.log('[MingDao] error 事件：' + ev.message); onActivity(); const d=document.createElement('div'); d.className='errline'; d.textContent=ev.message; msg.appendChild(d); scroll(); }
       else if(ev.type==='done'){ console.log('[MingDao] done 事件：session=' + ev.session); onActivity(); if(ev.budget){ const b=ev.budget; if(hintTextEl) hintTextEl.textContent='预算 '+Math.round(b.used/1000)+'K/'+Math.round(b.total/1000)+'K（'+Math.round(b.used/b.total*100)+'%）· 本轮完成 · 提示栏右侧为今日费用与命中率'; } refreshStatusBar(); if(ev.stats&&ev.stats.deliverables&&ev.stats.deliverables.length){ const card=document.createElement('div'); card.className='deliver'; card.innerHTML='<div class="t">📦 交付物（'+ev.stats.deliverables.length+' 个文件）</div>'+ev.stats.deliverables.map(f=>'<div class="i">'+esc(f)+(f.toLowerCase().endsWith('.html')?' <span style="color:var(--accent2)">— 浏览器打开即可运行</span>':'')+'</div>').join(''); msg.appendChild(card); } if(ev.note){ const d=document.createElement('div'); d.className='errline'; d.style.color='var(--warn)'; d.textContent=ev.note; msg.appendChild(d); } currentSession=ev.session; update(); refreshSessions(); updateTasksPanel(); }
     });
   }catch(e){ onActivity(); const d=document.createElement('div'); d.className='errline'; d.textContent=(e&&e.name==='AbortError')?(killedByWatchdog?'响应超时已中断（120 秒无任何响应），请重试':'已中断'):(e&&e.message)||'网络错误'; msg.appendChild(d); scroll(); }
-  finally{ clearInterval(hintTimer); disarm(); generating=false; setBtn(); console.log('[MingDao] 回合收尾：generating=false，按钮恢复发送'); hintEl.classList.remove('working'); if(hintTextEl) hintTextEl.textContent=defaultHint; pending=false; content.innerHTML=renderMarkdown(raw); scroll(); updateTasksPanel(); }
+  finally{ clearInterval(hintTimer); disarm(); generating=false; setBtn(); console.log('[MingDao] 回合收尾：generating=false，按钮恢复发送'); hintEl.classList.remove('working'); if(hintTextEl) hintTextEl.textContent=defaultHint; pending=false; content.innerHTML=renderMarkdown(raw); attachTrajMeta(msg); activeAiMsg=null; curWorkT0=0; renderWorkStatus(); scroll(); updateTasksPanel(); }
 }
 
 function abort(){ fetch('/api/abort',{method:'POST',headers:{'Content-Type':'application/json'},body:'{}'}).then(()=>updateTasksPanel()).catch(()=>{}); }
 
+// —— 输入框上方工作状态条（审计：长任务静默硬伤 → 实时进度可见） ——
+function renderWorkStatus(){
+  const el=$('#workStatus'); if(!el) return;
+  let html='';
+  if(generating){
+    const secs=curWorkT0?Math.round((Date.now()-curWorkT0)/1000):0;
+    html='<span class="ws-busy"><span class="spinner"></span>任务执行中：第 '+curSteps+' 步 · 已 '+Math.floor(secs/60)+' 分 '+Math.round(secs%60)+' 秒 — 完成后总结与交付物显示在本轮消息底部（停止请用输入框右侧「■ 停止」按钮）</span>';
+  } else if(bgRunning>0){
+    html='<span class="ws-bg">🛠 '+bgRunning+' 个后台任务运行中 — 点击查看</span>';
+  }
+  el.style.display=html?'flex':'none';
+  el.innerHTML=html;
+  const bg=el.querySelector('.ws-bg'); if(bg) bg.onclick=()=>{ const tp=$('#tasksPanel'); tp.style.display = tp.style.display==='none'?'flex':'none'; if(tp.style.display==='flex'){ $('#trajPanel').style.display='none'; updateTasksPanel(); } };
+}
+// 轨迹元行：任务完成后附在本轮消息顶部（步数/子代理数，点击打开轨迹面板）
+function attachTrajMeta(msg){
+  if(!msg || !msg._traj || !msg._traj.length) return;
+  const tools=msg._traj.filter(x=>x.kind==='tool');
+  const subs=tools.filter(x=>x.name==='task');
+  const meta=document.createElement('div'); meta.className='msg-meta';
+  const b=document.createElement('button'); b.className='trajBtn';
+  b.textContent='🧭 轨迹：'+(msg._steps||tools.length)+' 步 · '+subs.length+' 个子代理';
+  b.onclick=()=>openTraj(msg);
+  meta.appendChild(b);
+  msg.insertBefore(meta, msg.firstChild);
+}
+function openTraj(msg){
+  const list=$('#tjList'); list.innerHTML='';
+  const tools=msg._traj.filter(x=>x.kind==='tool');
+  const subs=tools.filter(x=>x.name==='task');
+  $('#tjSummary').textContent='（'+(msg._steps||tools.length)+' 步 · '+subs.length+' 个子代理）';
+  let turnN=0;
+  for(const e of msg._traj){
+    if(e.kind==='turn'){ turnN+=1;
+      const t=document.createElement('div'); t.className='tj-turn'; t.textContent='第 '+turnN+' 回合'; list.appendChild(t);
+      continue;
+    }
+    const isSub=e.name==='task';
+    const ico={'read':'📄','write':'✏️','edit':'✎','bash':'⚙','grep':'🔎','glob':'🔎','ls':'📁','task':'🤖','skill':'🧩','todo':'☑','undo':'↩'}[e.name]||'🔌';
+    const args = e.name==='bash' ? (e.args&&e.args.command) : (e.args&&(e.args.path||e.args.pattern||e.args.name||e.args.question||''))||'';
+    const div=document.createElement('div'); div.className='tj-item'+(isSub?' tj-sub':'');
+    const subLabel=isSub?'子代理：':'';
+    div.innerHTML='<div class="tj-head"><span>'+ico+'</span><span style="white-space:nowrap">'+esc(subLabel+e.name)+'</span><span class="tj-args">'+esc(String(args).slice(0,80))+'</span><span style="margin-left:auto;color:var(--faint)">'+(e.done?(e.denied?'✖ '+esc(e.denied):'✓'+(e.durationMs!=null?' '+e.durationMs+'ms':'')):'执行中…')+'</span></div>';
+    const body=document.createElement('div'); body.className='tj-body';
+    if(isSub){
+      body.textContent='任务：'+(e.args&&(e.args.question||e.args.prompt))+'\n\n结果：'+truncText(resultText(e.result), 1500);
+    }else if(e.result!==undefined){
+      body.textContent='参数：'+truncText(JSON.stringify(e.args||{}), 500)+'\n\n结果：'+truncText(resultText(e.result), 1500);
+    }else{
+      body.textContent='参数：'+truncText(JSON.stringify(e.args||{}), 500);
+    }
+    div.appendChild(body);
+    div.onclick=(ev)=>{ if(ev.target.closest('.tj-body')) return; div.classList.toggle('open'); };
+    // 点击标题定位到聊天中的对应工具卡
+    list.appendChild(div);
+  }
+  $('#trajPanel').style.display='flex';
+  $('#tasksPanel').style.display='none';
+}
+function resultText(r){
+  if(r==null||r===undefined) return '';
+  if(typeof r==='string') return r;
+  if(r.output) return String(r.output);
+  if(r.stdout||r.stderr) return String(r.stdout||'')+String(r.stderr||'');
+  return JSON.stringify(r);
+}
+function truncText(t,n){ t=String(t||''); return t.length>n?t.slice(0,n)+'\n…（截断，共 '+t.length+' 字）':t; }
+$('#tjClose').onclick=()=>{ $('#trajPanel').style.display='none'; };
 // —— 任务面板（多会话并行） ——
 function setBtn(){
   sendBtn.textContent = generating ? '■ 停止' : '发送';
@@ -762,6 +872,7 @@ function setBtn(){
 async function updateTasksPanel(){
   const r=await fetch('/api/tasks').catch(()=>null); if(!r) return;
   const j=await r.json(); const list=$('#tpList'); list.innerHTML='';
+  bgRunning=Number(j.running)||0; renderWorkStatus();
   $('#tpCount').textContent='（'+j.running+' 运行中 / 上限 '+j.maxConcurrent+'）';
   // 审计（第二问无反应修复）：generating 改为「本轮在途」本地状态，由 send/finally 维护，
   // 不再由 /api/tasks 轮询推导——任务面板瞬时波动或一次轮询失败曾让按钮永久卡在停止态，
@@ -1204,7 +1315,7 @@ $('#modelSel').addEventListener('change', e=>{ applyConfig({model:e.target.value
 $('#permSel').addEventListener('change', e=>{ applyConfig({permission:e.target.value}, e.target); });
 async function loadSession(file){ currentSession=file; chatEl.innerHTML=''; const r=await fetch('/api/session?file='+encodeURIComponent(file)); const j=await r.json(); for(const m of j.messages||[]){ if(typeof m.content==='string'&&m.content.startsWith('（系统提示）')) continue; if(m.role==='user') addUser(m.content); else { const el=newAiMsg(); aiContent(el).innerHTML=renderMarkdown(m.content); } } if(j.workspace){ const sel=$('#wsSel'); const has=[...sel.options].some(o=>o.value===j.workspace); if(has){ sel.value=j.workspace; } else { refreshWsSel(); } renderBanner({text:'↩ 已回到该会话的工作空间：'+j.workspace}); } scrollBottom(); }
 
-sendBtn.onclick=send;
+sendBtn.onclick=()=>{ if(generating){ abort(); } else { send(); } };
 input.addEventListener('keydown',e=>{ if(e.key==='Enter'&&!e.shiftKey){ e.preventDefault(); send(); } });
 input.addEventListener('input',()=>{ input.style.height='44px'; input.style.height=Math.min(input.scrollHeight,200)+'px'; });
 $('#newChat').onclick=()=>{ currentSession=null; chatEl.innerHTML=''; refreshSessions(); };

package/src/web/server.js

@@ -240,7 +240,7 @@ export async function runWebServer({ host = '127.0.0.1', port = 3820, authToken
       try {
         send({ type: 'progress', seconds: Math.round((Date.now() - entry.startedAt) / 1000), steps: io?.stats?.().toolCount || 0 });
       } catch {}
-    }, 8000);
+    }, 5000);
     const userMessage = String(body.message ?? '').trim();
     entry.message = (userMessage || '[附件]').slice(0, 40);
     const visionSupported = Boolean(modelPreset(modelName)?.supportsVision || cfg.customModels?.[modelName]?.vision);
@@ -270,7 +270,14 @@ export async function runWebServer({ host = '127.0.0.1', port = 3820, authToken
     let routeReason = null;
     if (routingConfig(cfg)) {
       try {
-        const route = await routeTask({ cfg, provider, currentModel: modelName, text: built.persistText || userMessage, sticky: session.lastRoute || null });
+        const route = await routeTask({
+          cfg,
+          provider,
+          currentModel: modelName,
+          text: built.persistText || userMessage,
+          sticky: session.lastRoute || null,
+          sessionStats: session.routeStats || null, // 会话级步数/截断统计（路由升级检测）
+        });
         session.lastRoute = route.model;
         if (route.model !== modelName) {
           runModel = route.model;
@@ -375,6 +382,9 @@ export async function runWebServer({ host = '127.0.0.1', port = 3820, authToken
     try {
       const r = await agent.runTurn(messages);
       srvlog('chat 回合完成 ' + taskId + ' text=' + String(r.text || '').length + ' ' + (Date.now() - entry.startedAt) + 'ms');
+      // 会话级路由统计（Hermes C2 升级检测）：累计工具步数与截断次数，粘滞 flash 会话复杂度上来后自动升 planner
+      const st = session.routeStats || { steps: 0, truncated: 0 };
+      session.routeStats = { steps: st.steps + (io.stats().toolCount || 0), truncated: st.truncated + (r.truncated ? 1 : 0) };
       appendMessages(session.file, messages.slice(persistedBefore));
       io.printUsageLine({ modelName: runModel, usage: r.usage, durationMs: r.durationMs });
       recordUsage(runModel, r.usage, r.perf);

package/src/web/web-io.js

@@ -29,16 +29,21 @@ export function createWebIO({ send, askHandler, setAbortHandler }) {
       send({ type: 'banner', title, lines });
     },
     // 每轮生成开始/结束：前端据此显示持续的「正在思考…」动态指示
+    // 审计（阶段切换静默）：turnStart 带累计工具步数；stopSpinner 在回合真正结束时
+    // 发 turnEnd——客户端据此显示「第 N 回合完成，进入下一回合…」，阶段边界不再静默
     beginTurn() {},
     endTurn() {},
     startSpinner() {
       if (!io._turnActive) {
         io._turnActive = true;
-        send({ type: 'turnStart' });
+        send({ type: 'turnStart', toolSteps: io._toolCount });
       }
     },
     stopSpinner() {
-      io._turnActive = false;
+      if (io._turnActive) {
+        io._turnActive = false;
+        send({ type: 'turnEnd', toolSteps: io._toolCount });
+      }
     },
     writeText(t) {
       send({ type: 'text', delta: String(t) });