mingdao-harness 0.1.65 → 0.1.67

package/README.md

@@ -7,7 +7,7 @@
 ## 为什么选 MingDao
 
 - ⚡ **真正的零依赖**：纯 Node.js ≥ 18，无任何 npm 运行时依赖、无构建步骤——装完即用，不拖 node_modules
-- 💰 **DeepSeek-V4 深度省钱**：384K 上下文预设、**缓存命中计价**（命中价仅为未命中的 1/30）+ 命中率仪表盘、峰谷计价（周末全天低价自动识别）、自动路由（pro 规划 / flash 执行 + 分类缓存 + 会话粘滞）、精确 tokenizer（官方词表 BPE）、滞回自动压缩、**Batch API 半价批处理**（`mingdao batch`）、**避峰调度**（`--offpeak` 高峰顺延 14: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,9 +89,9 @@ 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–14:00 为闲时 2 倍）。官方同时提供 Responses API 与 Anthropic 兼容接口；MingDao 默认走 OpenAI 兼容 chat/completions，如需原生协议可写自定义 Provider 模块。
+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 抽象已支持任意切换。
 5. **可靠性**：超时 + 指数退避重试，长上下文下避免瞬时错误中断任务。
 

package/docs/CONFIG.md

@@ -179,7 +179,11 @@ completion 计费，防止推理吃满上限时空轮白烧）、`compactTrigger
   分账（`batch` 标记）。端点不支持的网关会明确报错；可用 `config.batchBaseUrl` 指定支持
   批处理的网关、`batchEndpoint`/`batchWindow` 覆盖协议字段。
 - **避峰执行（高峰输入价 2 倍）**：`mingdao run --offpeak` / `mingdao schedule add --offpeak`
-  ——高峰时段（北京时间工作日 9:00–14:00）自动顺延到 14:00 后执行；**周末全天按闲时计价**
+  ——高峰时段（北京时间工作日 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

@@ -0,0 +1,85 @@
+# 六份第三方技术评估综合分析与优化路线（2026-08-27）
+
+对 `/persistent/home/YouLi/办公云盘/MingDao-Harness` 下六份评估（DuMate / Hermes / Kimi / MiniMax / OfficeACE×3 / workbuddy）逐份研读后，结合当前代码核实的综合结论与行动计划。
+
+## 一、报告结论速览
+
+| 报告 | 视角 | 结论 |
+|---|---|---|
+| DuMate | 逐文件代码审计 + 评分卡 | 架构 9/10、安全 9/10、可维护性 7/10；定位兑现度高 |
+| Hermes | 省钱定位深度剖析 + 冒烟实跑 | "实现程度高、技术路线正确"；缓存前缀稳定性是"最值钱的设计判断" |
+| Kimi | 实现度评估 | 8.2/10；发现 1 个 P0（峰谷窗口）与多个 P1（思考强度/上下文字段） |
+| MiniMax | Token 优化评估 | 重度使用可降至裸调 20–35%；P0-1"压缩破坏前缀"（与 Kimi 表扬相矛盾，经核实为观察角度差异） |
+| OfficeACE | 迭代方向 + 优化方案 O-01~O-19 | 8.5/10；显式缓存控制/技能压缩/路由优化为共识 P0 |
+| workbuddy | 全量克隆 + 实测 | 8.5/10；smoke 51 + e2e 16 全过 |
+
+**共识**：六份报告一致认可"省 Token 省钱"定位兑现度高；共同短板是 WebUI 单体、价格/词表数据硬编码、记忆检索弱、评测基准缺失。
+
+## 二、已核实并修正的问题（本版 0.1.66 实施）
+
+### P0-1 峰谷窗口与避峰顺延错误（Kimi 报告 P0，官方口径核实）
+- 现象：代码按单窗口"工作日 9:00–14:00 高峰"计价；`--offpeak` 把任务顺延到 14:00——恰是第二段高峰起点，**功能效果与意图相反**；14:00–18:00 费用被低估一倍。
+- 官方权威口径（https://api-docs.deepseek.com/zh-cn/quick_start/pricing/）：**高峰 = 北京时间周一至周五 9:00–12:00、14:00–18:00；其余为闲时；闲时价 = 高峰价一半**。
+- 已修复（`src/pricing.js` / `cli.js` / `schedule.js` / `tasks.js` / `models.js` / WebUI / README / docs / smoke 12 组断言）：
+  - `isPeakHour`：双窗口判定，午间 12:00–14:00 与周末全天为闲时；
+  - `deferToOffpeak`：上午高峰 → 顺延 12:00；下午高峰 → 顺延 18:00；闲时原时刻执行；
+  - 高峰窗口经 `config.pricing.peakWindows` 可配置（官方调整时可零代码跟随）；
+  - 新增 `peakStatusLabel()` 供面板/备注显示当前时段。
+
+### P0-2 桌面版「检查更新」点击无响应（用户反馈）
+- 现象：菜单点击后任何路径异常（electron-updater 导入失败 / 事件不触发 / 网络挂起）都会静默吞掉。
+- 已修复（`desktop/main.js`）：全程 try/catch + promise 结果兜底 + 30 秒超时兜底；已是最新时提示 **"当前版本：v0.1.66，已是最新版本"**；检查中并发给出可见反馈。
+
+### P1 桌面版设置改多级菜单（用户反馈）
+- 现象：⚙ 设置一拉到底（模型/同步/沙箱/调度/工作空间/记忆/仪表盘/MCP/技能库 9 块混排）。
+- 已修复（`src/web/index.html`）：左侧分组导航 + 右侧面板（🔑模型与密钥 / ☁️云同步与协作 / 🛡️通用与权限 / ⏰调度队列 / 📁工作空间 / 🧠长期记忆 / 📊缓存仪表盘 / 🔌MCP 生态 / 🧩技能库），记住上次分组、窄屏自动横向导航，全部控件 id 不变。
+
+### P1 界面与会话样式对齐 DeepSeek-Harness
+- 以 gitcode.com/MingDaoTCM/deepseek-harness 的 `packages/client/ui-theme/src/styles/design-platform.css` 实测值为准对齐暗色体系：
+  - 基色 `#151517`、侧栏 `#1B1B1C`、面板 `#2C2C2E`、悬浮 `#353638`、边框 `rgba(255,255,255,.12)`；
+  - 文字 `#F9FAFB` / `#ADB2B8` / `#81858C`；错误 `#F25A5A`、警告 `#F59E0B`；
+  - 用户气泡改 DSH 式扁平中性底 + **22px 圆角** + 16px/24px 排版（上限 min(525px,82%)）；
+  - 行内代码 `#2C2C2E` 底；代码块 `#1B1B1C` + 横幅 `#2C2C2E` + 12px 圆角 + 语言标签 + 一键复制；
+  - 主按钮 DSH 暗色近白填充；滚动条 `#3C3C3D`/hover `#545557`。
+
+## 三、下一步优化路线（按投入产出排序）
+
+### 近期（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 完全丢弃留一句概括。
+7. **增量式压缩**（Kimi P2-D）：`compressedUntil` 游标，只对增量段摘要，压缩输入从 O(历史) 降为 O(增量)。
+8. **护栏前置预估**（Kimi P2-E）：发请求前按"trimmed prompt×未命中价 + maxOutput×输出价"估算最坏成本，超限发送前拦截。
+9. **同回合工具去重 + 会话级 read 缓存**（Hermes C4 / MiniMax P2-2）：相同参数只读工具合并执行；read 按 mtime+size 去重。
+10. **工具 Schema 按需挂载**（MiniMax P3-5 / Hermes A1）：只读阶段只给 read/ls/glob/grep，每请求省 1–2K tokens。
+11. **Batch 输入侧优化**（Kimi P3-F）：文本哈希去重、单问超窗口报错、`--max-cost` 截断。
+12. **评测基准起步**（Hermes E2）：`test/bench/` 压缩质量集 / 路由准确率集 / tokenizer 黄金值回归。
+
+### 长期（0.3.x+，可选）
+13. 跨平台沙箱补位（Windows Job Object + 降权 token；macOS seatbelt）。
+14. tokenizer 缓存真 LRU + 大文本分级缓存（Kimi P3 / Hermes E3）。
+15. 费用二级分账（reasoning/tool 维度）+ WebUI 看板扩展。
+16. WebUI 单体拆分（`routes/` + 前端区块化）——与"轻量单文件易部署"权衡后分阶段做。
+
+## 四、不建议采纳（通用 AI 幻觉式建议）
+
+| 建议 | 原因 |
+|---|---|
+| TypeScript 全量迁移 / i18n 框架 / OpenTelemetry | 工具链级重写，与"零运行时依赖 + 单文件可部署"冲突；渐进 JSDoc 即可 |
+| onnxruntime WASM tokenizer / fasttext 本地分类器 / 向量嵌入检索（外部库） | 引入重依赖；语义检索可用 `node:sqlite` + 简单相似度保持零依赖 |
+| better-sqlite3 会话索引 | Node <22 无内置 `node:sqlite`；当前 JSONL+bigram 倒排够用 |
+| A/B 双模型对比路由 | 与省钱目标直接矛盾（同时调两模型） |
+| "固定 prefix 参数 / since message_id 增量 API" | 以可能不存在的 API 为前提 |
+| LLMLingua 压缩 / Speculative Execution | 外部库或高风险推测收益 |
+| MiniMax P0-1 "压缩延迟注入" | 与 Kimi 对滞回压缩的表扬相矛盾；压缩本就发生在轮间，收益被夸大 |
+
+## 五、口径勘误记录（报告间矛盾核实结果）
+
+- 峰谷窗口：Kimi 正确（双窗口），MiniMax 漏查 → 已按官方口径修复。
+- "无自动避峰调度"（OfficeACE 二/三）：不实，`run --offpeak` / `schedule add --offpeak` / WebUI 均已实现 → 本版修正了顺延目标。
+- 上下文窗口 384K vs 1M：Kimi 指出 384K 实为最大输出规格 → 0.1.67 已修正（contextWindow=1M、新增 maxOutputCeiling=384K、pro maxOutputTokens 32768→65536）。

package/docs/QA-REPORT.md

@@ -282,7 +282,7 @@ Retry-After 退避；远期：拆 cli.js、子代理并行、插件生命周期
 | --- | --- |
 | **Batch API 半价通道（A1）** | `src/batch.js` + `mingdao batch <文件|->`：单轮批量任务走 OpenAI 兼容批处理协议（上传→建批→轮询→取回），结果落盘 JSONL 并计入 `/cost` 分账（`batch:true`，×0.5 计价）；轮询连续失败 10 次报错、端点不支持明确报错；`batchBaseUrl/batchEndpoint/batchWindow` 可配。smoke #41 全协议 mock 演练 |
 | **费用护栏（A2）** | `src/cost-guard.js`：按北京时间自然日累计真实费用（含缓存折扣与 batch 半价），`costGuard{dailyLimitYuan,warnAtYuan,action:warn\|block}`；Agent 每轮开始前检查，block 时暂停并明确告知；`/cost`、WebUI 头部费用徽标实时显示。smoke #40 覆盖 |
-| **避峰调度** | `run --offpeak` / `schedule add --offpeak` / WebUI「🌙 避峰执行」：高峰（北京工作日 9:00–14:00）自动顺延到 14:00 后执行；**周末全天识别为闲时**（DeepSeek 2026-08 计费调整）。e2e-schedule #5 覆盖 |
+| **避峰调度** | `run --offpeak` / `schedule add --offpeak` / WebUI「🌙 避峰执行」：高峰（北京工作日 9:00–12:00、14:00–18:00，官方口径）自动顺延到最近闲时（12:00 / 18:00）执行；**周末与午间识别为闲时**。e2e-schedule #5 覆盖 |
 | **/cost 分账升级** | 按模型分账、今日费用、Batch 子项、节省归因（相比全未命中省 ¥X）、护栏状态；Web `/api/cache-stats` 同步输出 |
 | **token 预算可视化（A5）** | WebUI done 事件携带会话 token 占用/预算，提示栏显示 `预算 45K/128K（35%）`；头部费用徽标 15s 刷新「今日 ¥x · 命中 y% · 护栏 z%」 |
 | **Retry-After 退避（P3-1）** | provider 重试尊重 `Retry-After` 头（封顶 30s），错误对象透传响应头 |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mingdao-harness",
-  "version": "0.1.65",
+  "version": "0.1.67",
   "description": "MingDao Harness —— 开源智能体框架（Agent Harness）。零依赖、开箱即用，针对 DeepSeek-V4 系列优化，开放主流模型接入。",
   "type": "module",
   "bin": {

package/src/agent.js

@@ -26,6 +26,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 不丢失）
@@ -189,6 +190,7 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
           tools: [...toolSchemas(), ...mcpSchemas()],
           temperature,
           maxTokens: maxOutput,
+          reasoningEffort,
           signal: ac.signal,
           onDelta(d) {
             io.stopSpinner();
@@ -256,7 +258,13 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
             // 参数 JSON 解析失败：回填错误给模型，不拿空参数去执行工具
             io.renderToolDenied(name, {}, '参数解析失败（输出超限被截断？建议分块）');
             if (auditOn) auditEntry({ denied: true, reason: '参数解析失败' });
-            messages.push({ role: 'tool', tool_call_id: tc.id, content: '工具参数 JSON 解析失败，请重新输出合法参数。' });
+            // 审计（长生成截断循环）：给出明确分块指引，避免模型反复用单个超大 write 撞输出上限
+            messages.push({
+              role: 'tool',
+              tool_call_id: tc.id,
+              content:
+                '工具参数 JSON 解析失败（大概率是输出超过模型单次上限被截断）。请把内容拆分成多个较小文件或多次调用逐步写入：单个 write 的参数总长控制在 6000 字符以内；先写核心骨架，再逐文件补充。',
+            });
             return null;
           }
           if (!args || typeof args !== 'object' || Array.isArray(args)) args = {};

package/src/cli.js

@@ -201,10 +201,11 @@ async function runWorkerTask(id, question, { permission, model, offpeak }) {
       perm = 'readonly';
       note = 'ask 权限下后台任务按只读执行';
     }
-    // 避峰（评估 A2/Kimi P-1）：高峰时段（北京工作日 9:00–14:00）自动顺延到 14:00 执行，输入价省 50%
+    // 避峰（评估 A2/Kimi P-1）：高峰时段（北京工作日 9:00–12:00、14:00–18:00）
+    // 自动顺延到最近闲时起点（12:00 / 18:00）执行，输入价省 50%
     if (offpeak && isPeakHour(new Date())) {
       const defer = deferToOffpeak(new Date());
-      finish({ note: `避峰等待至 ${defer.toISOString().slice(11, 16)}（北京时间 14:00 后）` });
+      finish({ note: `避峰等待至北京时间 ${defer.toISOString().slice(11, 16)}（闲时起执行，输入价省 50%）` });
       await new Promise((r) => setTimeout(r, defer.getTime() - Date.now() + 2000));
       finish({ note: '' });
     }
@@ -779,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/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–14:00 为闲时 2 倍），支持工具调用 / 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,36 +12,88 @@ import { mingdaoHome } from './config.js';
 // 内置价格表的数据时点（定价可能调整，配置覆盖可随时更新）
 export const PRICE_DATA_AS_OF = '2026-08';
 
-// 峰谷判断锚定北京时间（评估 P0-4：DeepSeek 按北京时间 9:00–14:00 高峰计价，
-// 用本机时区判断会让海外用户计费错位）。config.pricing.timezone 可覆盖，mtime 缓存避免每次读盘。
-let tzCache = { mtime: 0, timezone: 'Asia/Shanghai' };
-function peakTimezone() {
+// 价格表外置（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 可覆盖时区、
+// config.pricing.peakWindows 可覆盖高峰窗口（[[起,止],...] 北京时间整点），mtime 缓存避免每次读盘。
+const DEFAULT_PEAK_WINDOWS = [[9, 12], [14, 18]];
+let tzCache = { mtime: 0, timezone: 'Asia/Shanghai', peakWindows: DEFAULT_PEAK_WINDOWS };
+function peakCfg() {
   try {
     const file = path.join(mingdaoHome(), 'config.json');
     const st = fs.statSync(file);
     if (st.mtimeMs !== tzCache.mtime) {
       const cfg = JSON.parse(fs.readFileSync(file, 'utf8'));
-      tzCache = { mtime: st.mtimeMs, timezone: String(cfg?.pricing?.timezone || 'Asia/Shanghai') };
+      const pw = cfg?.pricing?.peakWindows;
+      tzCache = {
+        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 {}
-  return tzCache.timezone;
+  return tzCache;
 }
 
 export function isPeakHour(date = new Date()) {
+  const { timezone, peakWindows } = peakCfg();
   try {
     const parts = new Intl.DateTimeFormat('en-US', {
-      timeZone: peakTimezone(),
+      timeZone: timezone,
       weekday: 'short',
       hour: 'numeric',
       hourCycle: 'h23',
     }).formatToParts(date);
     const weekday = parts.find((p) => p.type === 'weekday')?.value;
-    // 周末全天按闲时计价（DeepSeek 官方邮件确认：周六/周日全天闲时低价，批量任务周末更划算）
+    // 周末全天按闲时计价
     if (weekday === 'Sat' || weekday === 'Sun') return false;
     const hour = Number(parts.find((p) => p.type === 'hour')?.value);
-    return hour >= 9 && hour < 14;
+    return peakWindows.some(([s, e]) => hour >= s && hour < e);
   } catch {
-    return date.getHours() >= 9 && date.getHours() < 14; // 非法时区回退本机
+    const h = date.getHours();
+    return peakWindows.some(([s, e]) => h >= s && h < e); // 非法时区回退本机
   }
 }
 
@@ -49,7 +101,7 @@ export function isPeakHour(date = new Date()) {
 export function beijingParts(date = new Date()) {
   let tz = 'Asia/Shanghai';
   try {
-    tz = peakTimezone();
+    tz = peakCfg().timezone;
     new Intl.DateTimeFormat('en-US', { timeZone: tz }).format(); // 非法时区在此抛错
   } catch {
     tz = 'Asia/Shanghai'; // 审计 B1：坏时区配置回退北京时间，绝不让计费/护栏崩溃
@@ -73,11 +125,24 @@ export function beijingToDate(parts) {
   return new Date(Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second) - 8 * 3600 * 1000);
 }
 
-// 避峰：当前处于高峰（9:00–14:00）→ 顺延到当天 14:00；否则原时刻
+// 避峰顺延：当前处于高峰 → 顺延到该高峰段的结束整点（即最近一个闲时起点）
+//   · 9:00–12:00 高峰 → 12:00（午间闲时）
+//   · 14:00–18:00 高峰 → 18:00（晚间闲时）
+// 其余（午间/晚间/清晨/周末）原时刻执行。窗口可经 pricing.peakWindows 覆盖。
 export function deferToOffpeak(date = new Date()) {
   if (!isPeakHour(date)) return date;
   const p = beijingParts(date);
-  return beijingToDate({ ...p, hour: 14, minute: 0, second: 0 });
+  const w = peakCfg().peakWindows.find(([s, e]) => p.hour >= s && p.hour < e);
+  const targetHour = w ? w[1] : 18;
+  return beijingToDate({ ...p, hour: targetHour, minute: 0, second: 0 });
+}
+
+// 当前时段的人类可读描述（设置面板/调度备注共用）
+export function peakStatusLabel(date = new Date()) {
+  if (!isPeakHour(date)) return '闲时';
+  const p = beijingParts(date);
+  const w = peakCfg().peakWindows.find(([s, e]) => p.hour >= s && p.hour < e);
+  return `高峰（至 ${String(w ? w[1] : 18).padStart(2, '0')}:00）`;
 }
 
 // 北京时间当日 0 点（费用护栏按自然日累计）
@@ -119,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),
   };
 }
 
@@ -152,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/prompts.js

@@ -12,13 +12,14 @@ const BASE = `你是 MingDao Harness，一个由 MingDao Harness 驱动的 AI
 工作准则：
 1. 先了解再动手：修改或创建代码前，先用 read / ls / glob / grep 查看相关文件，不要凭空猜测。
 2. 精准修改：优先用 edit 做小步精确替换；新建文件用 write；保持改动最小化；改错可用 undo 撤销。
-3. 任务管理：多步骤任务先建 todo 清单并逐项更新；与技能（skill）相关的任务先加载对应 SKILL.md。
-4. 委托与专注：独立、可并行的子问题（调研、复核、独立实现）用 task 委托子代理，把结果拿回来继续主线。
-5. 命令谨慎：执行 bash 前想清楚影响；命令失败时阅读错误输出并修复，同一问题最多重试 3 次。
-6. 回答风格：使用用户的语言（默认中文），简洁直接，先结论后说明。
-7. 诚实可靠：不编造不存在的文件、行号、API 或执行结果。
-8. 善用工具：能用工具确认的事实就用工具确认；多个只读工具可连续调用以提高效率。
-9. 交付收尾：完成工具操作后必须给出简短交付总结——生成了哪些文件（路径）、如何运行/使用（如「浏览器打开 angry-birds.html 即可游玩」或运行命令）、以及未完成或注意事项（若有）。绝不能不声不响结束。`;
+3. 大内容分批写：单个 write 的参数总长控制在 6000 字符以内；大文件先写核心骨架，再分多次 write/edit 逐步补充——单次输出超限会被截断并导致参数解析失败。
+4. 任务管理：多步骤任务先建 todo 清单并逐项更新；与技能（skill）相关的任务先加载对应 SKILL.md。
+5. 委托与专注：独立、可并行的子问题（调研、复核、独立实现）用 task 委托子代理，把结果拿回来继续主线。
+6. 命令谨慎：执行 bash 前想清楚影响；命令失败时阅读错误输出并修复，同一问题最多重试 3 次。
+7. 回答风格：使用用户的语言（默认中文），简洁直接，先结论后说明。
+8. 诚实可靠：不编造不存在的文件、行号、API 或执行结果。
+9. 善用工具：能用工具确认的事实就用工具确认；多个只读工具可连续调用以提高效率。
+10. 交付收尾：完成工具操作后必须给出简短交付总结——生成了哪些文件（路径）、如何运行/使用（如「浏览器打开 angry-birds.html 即可游玩」或运行命令）、以及未完成或注意事项（若有）。绝不能不声不响结束。`;
 
 function loadFile(p, cap) {
   try {

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

@@ -37,7 +37,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 +52,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 +101,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 +115,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;